Skip to content
All categories

ai

1239 posts
aideep-dive

pgvector Deep Dive: Bringing Vector Search Back into PostgreSQL

pgvector is a PostgreSQL extension, not a standalone vector database. It adds exact and approximate vector search to the same data model, transactions, and operations stack, while leaving index tuning and horizontal scaling as PostgreSQL concerns.

aideep-dive

Portkey: Put LLM Routing, Observability, and Governance Behind One AI Gateway

Portkey sits between applications and model providers: one OpenAI-compatible endpoint adds routing, fallbacks, request logs, budgets, and guardrails, with an open-source gateway available for self-hosting.

Securing Private-Corpus Queries: ACLs, Deletion Propagation, and Freshness

Authorization must take effect before candidate generation, while ACLs, deletion events, and source versions must propagate to every derived index; freshness needs measurable event-time SLOs too.

Private Corpus Search Boundaries: Decide Where Data May Go First

The first private-corpus decision is not which vector database to buy. Define data classes, trust zones, policy enforcement points, and freshness SLAs so every index, model, and observability system receives only the minimum data it is allowed to process.

From Source to Index: Sync and Incremental Updates for Private Corpora

Private-corpus sync is not periodic refetching. It requires stable canonical IDs, source versions plus checksums for change detection, idempotent upserts, and tombstones that propagate deletion through every index.

aideep-dive

Promptfoo Deep Dive: Local-First LLM Evaluation and Red Teaming

Promptfoo combines prompts, providers, test cases, and assertions in YAML to produce repeatable local and CI evaluation matrices, with red teaming against the same targets. It lowers the testing barrier but does not remove output variance, LLM-judge bias, or hosted data-flow concerns.

aideep-dive

Pydantic AI: Building Python Agents with Types, Dependencies, and Validation

Pydantic AI models an agent as Agent[Deps, Output]: dependencies, tool inputs, and final outputs are typed, and model results must pass Pydantic validation.

aideep-dive

R2R Deep Dive: Ingestion, Hybrid Search, and RAG behind an API

R2R packages document ingestion, hybrid search, knowledge graphs, RAG, Agents, and access controls behind a REST API; it fits teams that already own their product frontend and backend and need a retrieval service.

aideep-dive

Choosing a RAG Framework: LlamaIndex, Haystack, RAGFlow, Dify, and R2R Operate at Different Layers

LlamaIndex and Haystack are code-first frameworks; RAGFlow and Dify are managed application platforms; R2R packages retrieval as an API service. Choose how much control your team needs over ingestion, retrieval, and operations before choosing a tool.

aideep-dive

RAGFlow Deep Dive: From Document Parsing and Chunk Review to Cited Answers

RAGFlow puts document parsing, human chunk review, retrieval tests, chat, and citations in one platform; it fits layout-heavy PDFs and tables, but carries more deployment weight and platform state than a Python library.

aideep-dive

Runloop: Devbox Infrastructure Built for Coding Agents

Runloop combines isolated microVMs, reproducible images, disk branching, credential proxies, and evals in one coding-agent platform; an official case study reports more than 10,000 concurrent Devboxes in one workload.

aideep-dive

Sail Research: Trading Latency for Cost in Long-Horizon Agent Inference

Sail Research lets each inference request declare a completion window, scheduling patient background agents on cheaper capacity, while Sailboxes provide persistent long-running execution environments.

From Search Results to Reliable Citations: URL Deduplication, Source Tiers, and Claim-Source Mapping

Reliable citation is not appending URLs to an answer. Separate URLs, content copies, and source independence, then connect atomic claims to quote spans and snapshots through a rerunnable claim-source matrix.

aideep-dive

Slack Code: Multiplayer AI Coding and the Agent Control Plane Landscape

Slack Code moves AI coding agents from individual terminals into shared Slack channels where teams can see diffs, previews, and plans in real time. But it solves management's visibility anxiety, not engineers' productivity bottleneck — the real battle is over who becomes the agent control plane.

Overview: Defining Intelligence Under Resource Constraints | Stanford CS221 Lecture 1

Lecture 1 of Stanford CS221 Autumn 2025 develops operational representations and algorithmic intuition through Overview: Defining Intelligence Under Resource Constraints.

Learning I: From Computation Graphs to Linear Regression | Stanford CS221 Lecture 2

Lecture 2 of Stanford CS221 Autumn 2025 develops operational representations and algorithmic intuition through Learning I: From Computation Graphs to Linear Regression.

Learning II: Linear Classification, Features, and Cross-Entropy | Stanford CS221 Lecture 3

Lecture 3 of Stanford CS221 Autumn 2025 develops operational representations and algorithmic intuition through Learning II: Linear Classification, Features, and Cross-Entropy.

Learning III: Deep Networks as Composable Computation Graphs | Stanford CS221 Lecture 4

Lecture 4 of Stanford CS221 Autumn 2025 develops operational representations and algorithmic intuition through Learning III: Deep Networks as Composable Computation Graphs.

Search I: Define the State Before Choosing the Algorithm | Stanford CS221 Lecture 5

Lecture 5 models search with states, actions, successors, and costs, then uses acyclic dynamic programming to show that an efficient algorithm still solves the wrong problem when state omits information needed by the future.

Search II: Priorities in UCS and A* | Stanford CS221 Lecture 6

Lecture 6 of Stanford CS221 Autumn 2025 follows the official material on Search II: Priorities in UCS and A* and makes its assumptions and limits explicit.