mcp-use

Enables building autonomous AI agents that decompose complex tasks into sequential steps using MCP tools. The MCPAgent class (available in both Python and TypeScript) manages tool discovery, invocation, and result aggregation across multiple MCP servers, with built-in support for streaming responses and structured output. Agents maintain conversation context and can reason across tool calls to accomplish multi-step objectives.

Provides a synchronous and asynchronous client interface (MCPClient) for directly calling MCP server tools without LLM intermediation. The client handles connection management, tool discovery via MCP's list_tools protocol, parameter validation against tool schemas, and result parsing. Supports both stdio and HTTP transports with automatic reconnection and error handling.

Supports declarative configuration (YAML/JSON) for defining MCP servers, connectors, and deployment parameters without code changes. Configuration files specify server definitions (name, type, transport, executable path), authentication credentials, resource limits, and deployment targets. Framework loads configuration at runtime and instantiates servers/connectors accordingly, enabling environment-specific configurations.

Provides optional sandboxing for tool execution to isolate untrusted code and limit resource access. Sandboxing can restrict file system access, network calls, and CPU/memory usage through OS-level mechanisms (containers, seccomp, resource limits). Framework provides configuration options to enable/disable sandboxing per tool or globally.

Provides mechanisms for authenticating to MCP servers and managing credentials (API keys, OAuth tokens, basic auth). Framework supports multiple authentication schemes (API key headers, OAuth 2.0, mTLS) with credential injection from environment variables or secret stores. Authentication is configured per server and applied automatically to all requests.

Integrates observability hooks throughout agent execution for collecting metrics, traces, and logs. Framework emits telemetry events for tool invocations, LLM calls, errors, and performance metrics. Telemetry can be exported to standard backends (OpenTelemetry, Datadog, CloudWatch) through pluggable exporters. Includes built-in metrics for latency, token usage, and error rates.

Enables agents to generate and execute code (Python or JavaScript) dynamically to accomplish tasks, with sandboxed execution for safety. Code execution mode allows agents to write custom scripts that invoke MCP tools, process results, and make decisions without predefined tool schemas. Execution environment has access to tool libraries and can import standard libraries.

Enables building custom MCP servers that expose tools, resources, and prompts to LLMs and clients. The TypeScript SDK provides decorators and class-based patterns for defining server capabilities, with automatic schema generation and protocol compliance. Servers handle incoming MCP requests, execute handler functions, and return results with proper error serialization. Supports both stdio and HTTP server modes for deployment flexibility.

Manages connections to multiple MCP servers through a unified connector interface, handling server lifecycle (startup, shutdown, reconnection), capability discovery, and request routing. The Python SDK's Connectors and Sessions layer abstracts transport details (stdio, HTTP, SSE) and provides automatic server process management for local servers. Sessions maintain state across multiple tool invocations and support concurrent server interactions.

Provides a web-based UI for discovering, testing, and debugging MCP servers in real-time. The Inspector connects to running MCP servers, displays available tools/resources/prompts with their schemas, allows manual tool invocation with parameter input, and shows request/response logs. Built as a standalone TypeScript application that can be launched via CLI, supporting both local and remote server inspection.

Provides CLI tooling (create-mcp-use-app) for generating boilerplate MCP application projects with pre-configured dependencies, example code, and build setup. Scaffolding supports multiple project types (MCP server, MCP client, MCP agent) and languages (TypeScript, Python), with automatic dependency installation and development environment setup. Generated projects include example implementations and configuration templates.

Provides a CLI tool (mcp-use build) for compiling TypeScript MCP servers into distributable bundles with dependency bundling and optimization. The build tool handles TypeScript compilation, tree-shaking unused code, bundling dependencies, and generating executable entry points. Supports both stdio and HTTP server output formats with automatic platform-specific binary generation.

Enables agents and clients to handle streaming responses from tools and LLMs, with support for structured output parsing and validation. The framework provides streaming abstractions that yield partial results as they arrive, with optional JSON schema validation for structured responses. Streaming works across both Python and TypeScript implementations with consistent API surface.

Manages conversation history and context across multiple agent interactions, with support for different memory strategies (sliding window, summarization, full history). The framework maintains context state, handles token counting for context windows, and provides hooks for custom memory implementations. Memory is integrated into agent reasoning loop to inform tool selection and response generation.

Implements a middleware pipeline architecture that allows injecting custom logic at key points in agent execution: before/after tool invocation, before/after LLM calls, and on errors. Middleware receives execution context (tool name, parameters, results) and can modify behavior, log telemetry, or trigger side effects. Pipeline is composable, allowing multiple middleware to chain together.