mcp-use

Implements MCPAgent classes in both Python and TypeScript that enable LLMs to reason across multiple steps using MCP-exposed tools, managing tool discovery, invocation, and result integration into agent context. Uses a middleware pipeline architecture to intercept and transform tool calls, supporting streaming responses and structured output formats while maintaining conversation state across multi-turn interactions.

Provides MCPClient classes (Python and TypeScript) that establish connections to MCP servers and enable direct, synchronous invocation of exposed tools without requiring an LLM in the loop. Handles transport protocol abstraction (stdio, HTTP, WebSocket), server capability discovery, and result marshaling into native language types, allowing developers to use MCP tools as a standard library.

Provides built-in telemetry collection that tracks agent execution metrics (tool invocation counts, latency, error rates), reasoning traces (step-by-step agent decisions), and resource usage (token counts, memory). Integrates with standard observability platforms (OpenTelemetry, Datadog, CloudWatch) for centralized monitoring and alerting.

Provides optional sandboxing for tool execution that isolates untrusted code from the host system, preventing malicious tools from accessing files, network, or system resources. Uses OS-level isolation (containers, VMs) or JavaScript sandboxing (for TypeScript tools) to enforce resource limits and capability restrictions.

Implements configuration file formats (YAML, JSON) and environment variable support that allow agents and servers to be configured without code changes, enabling different configurations for development, staging, and production environments. Supports configuration inheritance, variable substitution, and validation against schemas.

Provides authentication mechanisms (API keys, OAuth2, mTLS) for securing MCP server access, ensuring only authorized clients can invoke tools. Supports per-server authentication configuration and integrates with standard auth providers (OpenAI, Anthropic, custom OAuth2 servers).

Provides create-mcp-use-app CLI tool and build system that generates boilerplate MCP server projects with pre-configured tool, resource, and prompt handlers. Uses TypeScript decorators and class-based patterns to define server capabilities, automatically generating MCP protocol-compliant schemas and handling transport setup (stdio, HTTP) without manual protocol implementation.

Implements Connectors and Sessions (Python) and multi-server management patterns that allow agents and clients to connect to multiple MCP servers simultaneously, routing tool calls to the correct server based on tool availability. Uses a session-based architecture where each session maintains independent server connections and state, enabling isolation between concurrent agent instances or multi-tenant scenarios.

Implements automatic server capability discovery that queries MCP servers for their exposed tools, resources, and prompts, returning structured schema definitions that agents and clients use to understand what operations are available. Uses MCP protocol's list_tools, list_resources, and list_prompts messages to dynamically build capability inventories without requiring hardcoded tool definitions.

Provides streaming response handling that allows agents to emit tokens incrementally as they reason, enabling real-time UI updates and progressive result delivery. Supports structured output formats (JSON, XML) that agents can use to return results in machine-readable form, with automatic schema validation and type coercion to native language objects.

Implements conversation history tracking and memory management that persists agent reasoning steps, tool invocations, and results across multiple turns, enabling agents to reference prior context when making decisions. Uses message-based architecture where each turn appends to a conversation log, with configurable memory strategies (full history, sliding window, summarization) to manage context window constraints.

Provides a web-based interactive debugger (MCP Inspector) that visualizes MCP protocol messages in real-time, allowing developers to inspect tool schemas, test tool invocations, and debug server/client communication. Displays request/response pairs with syntax highlighting, enables manual tool invocation with JSON argument editing, and logs all protocol messages for post-mortem analysis.

Abstracts MCP transport mechanisms (stdio, HTTP, WebSocket) behind a unified interface, allowing servers and clients to be deployed with different transports without code changes. Handles protocol negotiation, connection lifecycle management, and message serialization/deserialization for each transport type, with automatic fallback and error handling.

Implements a middleware pipeline architecture that allows custom interceptors to be inserted into the tool invocation flow, enabling cross-cutting concerns like logging, caching, validation, and result transformation without modifying agent or tool code. Middleware runs in sequence, with each middleware able to inspect/modify requests before invocation and responses after completion.