MCP servers, agents, and the rest of the AI build stack — with the trade-offs, not just the pitch.

The MCP reference server collection provides maintained implementations — filesystem, fetch, memory, git, sequential thinking — that serve as both working connectors and the canonical example of how to write an MCP server correctly.

This is the repository to read before writing your own server. The implementations are deliberately small and show the protocol's shape: tool declaration, argument schemas, structured results and error handling. Most teams start by running one of these, then fork the closest match.

The GitHub MCP Server lets an agent read and act on repositories, issues, pull requests, code search and Actions through GitHub's own maintained connector.

Vendor-maintained, which matters more than it sounds: GitHub's API surface moves, and a first-party server tracks it. It turns 'review this PR' or 'find where this function is called across the org' into a single tool call instead of a shell script wrapping the REST API.

Playwright MCP drives a real browser from an agent using the accessibility tree rather than screenshots, so the model reads page structure as text instead of guessing at pixels.

The accessibility-tree approach is the important design decision. Vision-based browser agents burn tokens on screenshots and misidentify elements; a structured tree gives the model named, addressable controls. Practical for end-to-end test authoring, scraping behind a login, and any workflow that only exists as a web UI.

A PostgreSQL MCP server exposes schema inspection and read-only SQL to an agent, letting it answer data questions by writing queries instead of being fed exports.

The pattern that makes this work is schema-first: the agent reads table and column definitions, then writes SQL against them. That is far more reliable than dumping rows into context, and it scales to databases far larger than any context window.

The Sentry MCP Server pulls production errors, stack traces and issue context into an agent's working set so a fix can be written against the real failure rather than a pasted snippet.

Closes the loop between 'something broke in production' and 'here is the patch'. The agent reads the issue, the stack trace and the surrounding events, then works in the repository with that context already loaded.

A Slack MCP server gives an agent read and post access to channels and threads, which is how most internal assistants end up reaching the humans they work for.

Two distinct uses: reading — mining channel history for decisions and context that never made it into a document — and writing — posting summaries, alerts and requests for approval where people already are.

The Fetch MCP server retrieves a URL and converts it to clean markdown, giving a model readable page content instead of raw HTML it would waste most of its context parsing.

The smallest useful MCP server and a good first one to run. HTML-to-markdown conversion typically cuts token count by an order of magnitude while improving comprehension, because navigation chrome and inline scripts never reach the model.

The Memory MCP server stores facts as a local knowledge graph of entities and relations, giving an agent recall that survives past the end of a conversation.

A deliberately simple persistence layer: the agent writes entities, relations and observations, then queries them on later runs. Useful as the reference model for what agent memory means before committing to a heavier managed offering.

The Claude Agent SDK packages the Claude Code harness as a library, shipping the agent loop, context management, file and shell tools, subagents, hooks and permissions behind a single query call.

Available for Python and TypeScript. You supply a prompt and options; the SDK supplies the loop and a working toolset — read, write, edit, bash, glob, grep, web search — plus MCP support for anything else. It is a harness, not a hosting platform: you still deploy and run it yourself.

The Tool Runner in the official Anthropic SDKs drives the call-execute-loop cycle over tools you define, removing the boilerplate agent loop without adding a framework.

You write the tool functions; the SDK handles the iteration until the model stops requesting tools. Per-turn hooks give you approval gates, error interception and result modification. Distinct from the Claude Agent SDK — no built-in tools and no sandbox, just the loop.

LangGraph models an agent as an explicit state graph of nodes and edges, making control flow, checkpointing and human-in-the-loop interrupts first-class rather than emergent.

The graph is the point. Where a plain loop leaves control flow implicit in prompt text, LangGraph makes it inspectable code: you can see every path, resume from a checkpoint, and pause for human approval at a named node. That structure is what makes cyclical, long-running workflows debuggable.

The OpenAI Agents SDK is a deliberately small framework built on agents, handoffs between them, guardrails and built-in tracing.

The primitive set is intentionally minimal — agent, handoff, guardrail, session — which keeps it readable in a way larger frameworks are not. Tracing is built in rather than bolted on, so you can see a run's structure without adding an observability vendor first.

Pydantic AI brings typed, validated model outputs to agent building, treating an LLM response as a schema-checked Python object rather than a string to parse and hope about.

Built by the Pydantic team, so validation is the core rather than an add-on: you declare the result type, and the framework enforces it, retrying on validation failure. Model-agnostic, with dependency injection for testability.

The Vercel AI SDK is the default TypeScript toolkit for streaming model responses into a UI, with one provider-agnostic interface and first-class React hooks.

It solves the part most teams underestimate: streaming tokens, tool calls and structured objects into a browser without writing transport plumbing. Provider switching is a one-line change, which makes it the pragmatic choice for full-stack TypeScript products.

CrewAI organizes multiple agents as a crew with assigned roles, goals and delegation, which makes multi-agent designs quick to express and quick to demonstrate.

The role metaphor — researcher, writer, reviewer — is genuinely productive for getting a multi-agent prototype running in an afternoon. Sequential and hierarchical process models cover most collaboration shapes without hand-wiring message passing.

Mastra is a TypeScript agent framework bundling workflows, agent memory, RAG and evals in one opinionated stack rather than leaving them to be assembled.

Aimed at TypeScript teams who want LangGraph-style durable workflows without leaving the Node ecosystem. Durable workflow steps, typed tool definitions and built-in evaluation reduce the number of separate libraries a project has to hold together.

Claude Code is a terminal-native coding agent that reads a repository, plans a change, edits files, runs commands and iterates on the output — available in the CLI, desktop and web apps, and as IDE extensions.

The terminal-first design is a real architectural choice: the agent works where the build, tests and git already live, so verification is a command away rather than a plugin API away. Extensible through MCP servers, skills, hooks and subagents.

Cursor is a VS Code-derived editor with codebase-wide indexing, multi-file agent edits and inline completion built into the editing surface rather than added beside it.

Because it forks the editor rather than extending it, the AI features reach further than a plugin can — repository-wide semantic index, agent edits applied as reviewable diffs, and rules files that constrain behavior per project. The migration cost from VS Code is close to zero.

GitHub Copilot provides inline completion, chat and agent modes across major IDEs, with pull-request review and enterprise policy controls wired into GitHub itself.

The enterprise default, and usually for procurement reasons rather than capability ones: it is already inside the GitHub agreement, the admin controls exist, and IP indemnification is on the table. Broad IDE coverage means it fits teams that have not standardized on one editor.

Aider is an open-source terminal coding agent that edits a git repository directly and commits each change, giving every AI edit its own reviewable, revertible commit.

Git integration is the defining feature: because each change lands as a commit, `git diff` and `git revert` are the review and undo mechanism, with no proprietary state to trust. It builds a repository map to work on codebases far larger than a context window, and is model-agnostic.

Cline is an open-source VS Code extension that runs an autonomous coding agent inside the editor, asking permission before each file edit and terminal command.

The permission-per-action model is the distinguishing choice: you see and approve each step rather than reviewing a finished result, which is a reasonable trade while learning how far to trust an agent. Bring-your-own-key and MCP support keep it provider-neutral.

Continue is an open-source assistant for VS Code and JetBrains that runs against any model — including self-hosted ones — making it the practical route to AI assistance without code leaving your network.

Configuration-driven and model-agnostic by design: point it at a hosted API or a local runtime and the same interface works. For regulated environments, pairing it with a locally served open-weight model is often the only assistant setup that clears review.

The Model Context Protocol is an open standard for connecting AI assistants to tools and data sources, so one server implementation works with every compatible client instead of once per assistant.

MCP defines how servers advertise tools, resources and prompts, and how clients invoke them. Its value is combinatorial: N integrations across M assistants collapses from N×M bespoke connectors to N servers. Adoption across major assistants and IDEs is what turned it into the default integration layer.

Agent Skills package procedural knowledge — instructions, scripts and reference files — into folders a model loads only when a task actually calls for them, keeping specialized expertise out of the base prompt.

A skill is a directory with a description and instructions, optionally carrying executable scripts and reference documents. The model reads the description, decides relevance, and loads the body on demand. That progressive disclosure is the point: a hundred skills cost almost nothing until one is needed.

llms.txt is a proposed convention for publishing a markdown file at a site's root that gives language models a curated, navigable map of its documentation.

Where robots.txt says what crawlers may access, llms.txt says what a model should read and in what order — an index of the pages that actually matter, in a format that costs few tokens to consume. Adoption among developer-tool documentation sites has been the fastest.

Repomix packs an entire repository into a single AI-friendly file with token counts and configurable ignore rules, so a whole codebase can be handed to a model in one paste.

Solves the mundane problem of getting a codebase into a chat interface that has no repository access. Respects ignore rules, reports token counts before you exceed a limit, and can strip comments to fit more signal into the same window.

Tree-sitter is an incremental parser that produces a concrete syntax tree for source code, making it the standard way to chunk code along real function and class boundaries instead of arbitrary line counts.

Unglamorous infrastructure under most serious code AI. Naive chunking splits a function in half and retrieval quality collapses; syntax-aware chunking keeps semantic units intact. Grammars exist for essentially every mainstream language, and parsing is fast enough to run on every keystroke.

pgvector adds vector similarity search to PostgreSQL, letting embeddings live in the database you already run, back up and know how to operate.

The correct default for most teams. Vectors sit beside relational data, so a query can filter by tenant, date and permission in the same statement as the similarity search — a join that separate vector databases make awkward. Supports exact and approximate indexes.

Qdrant is an open-source vector database written in Rust with strong payload filtering, available self-hosted or as a managed cloud service.

Its filtering implementation is the differentiator — combining metadata predicates with vector search without the recall collapse that naive post-filtering causes. Quantization options cut memory substantially, which is what makes large collections affordable.

Weaviate is an open-source vector database with built-in hybrid search, combining keyword and vector scoring in a single query with a schema-first data model.

Hybrid search out of the box matters more than the marketing suggests: pure vector search misses exact identifiers, error codes and product SKUs that keyword search catches trivially. Weaviate can also generate embeddings via configured modules rather than in your application.

Chroma is an embedding database designed for the fastest possible path from idea to working retrieval, running in-process with no server to start.

The developer-experience choice: a few lines gets you a working collection, with persistence to disk when you want it and a client-server mode when you outgrow embedded use. The right tool for finding out whether retrieval helps at all before investing in infrastructure.

LlamaIndex is a data framework for connecting private data to language models, covering ingestion, parsing, chunking, indexing and query strategies rather than storage.

Storage is the easy part of RAG; getting messy PDFs, spreadsheets and web pages into clean, well-chunked text is the hard part, and that is what LlamaIndex addresses. It also implements advanced query strategies — reranking, multi-step decomposition, routing — that measurably beat naive top-k retrieval.

Pinecone is a fully managed vector database with serverless scaling, chosen by teams who want retrieval infrastructure they never operate.

The trade is explicit: no cluster to size, patch or rebalance, in exchange for a vendor dependency and usage-based cost. For teams without platform engineers, that is frequently the correct economics — an engineer's time spent on vector infrastructure is rarely cheaper.

Langfuse is an open-source LLM engineering platform for tracing, prompt management, evaluation and cost tracking, self-hostable so traces never leave your infrastructure.

Self-hosting is the deciding factor for many teams: traces contain prompts and outputs, which routinely include customer data, and shipping that to a third party is a compliance conversation. Framework-agnostic instrumentation and prompt versioning cover the day-to-day needs.

LangSmith provides tracing, dataset management, evaluation and prompt versioning as a managed platform, with the tightest integration into LangChain and LangGraph applications.

Inside the LangChain ecosystem, instrumentation is close to free — set an environment variable and traces appear with the graph structure intact. The dataset and evaluator workflow is mature: capture real production traces, curate them into a test set, and run regressions against every prompt change.

Braintrust is an evaluation-first platform for AI products, built around running scored experiments against datasets so prompt and model changes can be compared on evidence.

Where most tools start from tracing and add evals, Braintrust starts from evals and adds tracing. The workflow is experiment-shaped: define a dataset, define scorers, run variants, compare. That framing is what stops prompt engineering from being guesswork.

Phoenix is an open-source observability and evaluation tool for LLM and RAG applications, built on OpenTelemetry and runnable locally in a notebook.

Standing on OpenTelemetry matters: traces are portable to any OTel-compatible backend rather than trapped in a vendor schema. Phoenix also ships RAG-specific analysis — retrieval relevance, response groundedness — that generic APM tools do not model.

The OpenTelemetry semantic conventions for generative AI define standard attribute names for model calls, tokens and tool invocations, so LLM telemetry lands in the observability stack you already run.

The strategically safe choice. Instrument to the convention and traces flow to any OTel backend — your existing APM included — instead of a separate silo owned by one AI-observability vendor. Increasingly emitted natively by SDKs and frameworks.

Promptfoo is a command-line tool for testing prompts and red-teaming LLM applications from a declarative config, designed to run in CI like any other test suite.

Config-driven and local-first: describe test cases and assertions in YAML, run the matrix across prompts and models, get a pass/fail result a build can gate on. The red-teaming side probes for jailbreaks, prompt injection and PII leakage before an attacker does.

LiteLLM exposes many model providers behind one consistent interface, as a Python library or a self-hosted proxy with keys, budgets, rate limits and fallbacks.

The proxy mode is what makes it infrastructure rather than a convenience wrapper: one endpoint for every team, per-key budgets and spend tracking, automatic fallback when a provider degrades. Provider changes become a configuration edit rather than a code change.

OpenRouter is a hosted gateway offering hundreds of models from many providers through one API and one bill, with automatic routing around provider failures.

Removes the account-per-provider problem: one key, one invoice, and the ability to try a model you have no contract with in a single line change. Useful for evaluation work where signing procurement agreements per model is the actual bottleneck.

vLLM is a high-throughput inference server for open-weight models whose paged attention memory management makes serving concurrent users on your own GPUs practical.

The de facto standard for self-hosted serving at scale. Continuous batching and paged KV-cache management deliver throughput that naive serving cannot approach, and the OpenAI-compatible endpoint means most clients work unchanged.

Ollama runs open-weight models locally with a single command and serves them over a local HTTP API, making a developer laptop a usable model host.

It collapsed local model setup from an afternoon of CUDA and quantization decisions into one command. That matters for offline development, for prototyping against a model with zero marginal cost, and for privacy-sensitive experiments that must never leave the machine.

llama.cpp is a C/C++ inference engine that runs quantized open-weight models efficiently on CPUs and consumer hardware, with no GPU required.

The engine underneath much of the local-model ecosystem, including tools that never mention it. Its GGUF quantization formats are what make multi-billion-parameter models fit in consumer memory, and it runs on hardware from servers to phones.

Portkey is an AI gateway combining routing, caching, retries, guardrails and observability behind one endpoint, aimed at teams running models in production across several providers.

Bundles concerns most teams otherwise assemble from three or four tools: semantic caching to cut repeat cost, conditional routing by request attributes, and request-level tracing. A self-hosted deployment option exists for teams that cannot route through a vendor.

Guardrails AI validates model input and output against composable checks — schema conformance, PII, toxicity, competitor mentions — and can re-ask the model when a check fails.

Validation is expressed as reusable validators from a shared hub rather than bespoke regex scattered through application code. The re-ask loop is the useful part: a failed check can trigger a corrective retry rather than surfacing an error to the user.

NeMo Guardrails constrains conversational AI using Colang, a dedicated modeling language for defining permitted dialogue flows and topic boundaries.

Distinct from output filters: rather than checking a finished response, it constrains the conversation's shape — which topics are in scope, which flows are permitted, when to hand off to a human. Suits regulated conversational products where off-topic answers are a compliance issue.

Llama Guard is an open-weight classifier that labels prompts and responses against a configurable safety taxonomy, deployable as a self-hosted filter on both sides of a model call.

Because it is a model rather than a rule set, it generalizes to phrasings a keyword filter misses, and the taxonomy is editable to your own policy categories. Self-hosting means content being screened never leaves your infrastructure — often the reason a moderation API is not an option.

Presidio detects and anonymises personally identifiable information in text and images, letting sensitive fields be redacted or reversibly tokenized before a prompt leaves your systems.

Combines named-entity recognition, regex patterns and checksum validation, with country-specific recognizers for identifiers like national insurance and tax numbers. Anonymisation is pluggable — redact, hash, or reversibly encrypt so a response can be re-identified after the model call.