> ## Documentation Index > Fetch the complete documentation index at: https://docs.mcp-use.com/llms.txt > Use this file to discover all available pages before exploring further. # Mcpagent > MCP: Main integration module with customizable system prompt API Documentation export const RandomGradientBackground = ({className, color, children, grayscaled = false}) => { const saturation = useMemo(() => { if (color) { const values = color.split("(")[1].split(")")[0].trim().split(/\s+/); return parseFloat(values[1] || "0"); } return grayscaled ? 0 : 0.2; }, [color, grayscaled]); const lightness = useMemo(() => { if (color) { const values = color.split("(")[1].split(")")[0].trim().split(/\s+/); return parseFloat(values[0] || "0.5"); } return grayscaled ? 0.3 : 0.4; }, [color, grayscaled]); const randomHue = useMemo(() => { if (color) { const values = color.split("(")[1].split(")")[0].trim().split(/\s+/); return parseFloat(values[2] || "0"); } return Math.floor(Math.random() * 360); }, [color]); const randomColor = useMemo(() => { if (color) { return color; } return `oklch(${Math.min(lightness, 1)} ${saturation} ${randomHue})`; }, [randomHue, saturation, lightness]); const lightColor = useMemo(() => { return `oklch(${Math.min(lightness * 2, 1)} ${saturation} ${randomHue})`; }, [randomHue, saturation, lightness, color]); const direction = useMemo(() => { return Math.floor(Math.random() * 360); }, [randomHue]); const brightnessFilter = useMemo(() => { return "1000%"; }, []); return
{children &&
{children}
}
; }; View the source code for this module on GitHub: [https://github.com/mcp-use/mcp-use/blob/main/libraries/python/mcp\_use/agents/mcpagent.py](https://github.com/mcp-use/mcp-use/blob/main/libraries/python/mcp_use/agents/mcpagent.py) MCP: Main integration module with customizable system prompt. This module provides the main MCPAgent class that integrates all components to provide a simple interface for using MCP tools with different LLMs. LangChain 1.0.0 Migration: * The agent uses create\_agent() from langchain.agents which returns a CompiledStateGraph * New methods: astream\_simplified() and run\_v2() leverage the built-in astream() from CompiledStateGraph which handles the agent loop internally * Legacy methods: stream() and run() use manual step-by-step execution for backward compatibility ## MCPAgent
class MCPAgent
Main class for using MCP tools with various LLM providers. This class provides a unified interface for using MCP tools with different LLM providers through LangChain's agent framework, with customizable system prompts and conversation memory.
```python theme={null} from mcp_use.agents.mcpagent import MCPAgent ``` ### `method` **init** Initialize a new MCPAgent instance. **Parameters** > The LangChain LLM to use. Not required if agent\_id is provided for remote execution. > The MCPClient to use. If provided, connector is ignored. > A list of MCP connectors to use if client is not provided. > The maximum number of steps to take. > Whether to automatically initialize the agent when run is called. > Whether to maintain conversation history for context. > Complete system prompt to use (overrides template if provided). > Template for system prompt with {tool_descriptions} placeholder. > Extra instructions to append to the system prompt. > List of tool names that should not be available to the agent. > List of tools > Whether to use server manager mode instead of exposing all tools. > Server name or configuration > Enable debug/verbose mode > Whether to pretty print the output. > Remote agent ID for remote execution. If provided, creates a remote agent. > API key for remote execution. If None, checks MCP\_USE\_API\_KEY env var. > Base URL for remote API calls. > List of LangChain callbacks to use. If None and Langfuse is configured, uses langfuse\_handler. > String value > Whether to enable automatic error handling for tool calls. When True, tool errors **Signature** ```python wrap theme={null} def __init__(llm: langchain_core.language_models.base.BaseLanguageModel | None = None, client: mcp_use.client.client.MCPClient | None = None, connectors: list[mcp_use.client.connectors.base.BaseConnector] | None = None, max_steps: int = 5, auto_initialize: bool = False, memory_enabled: bool = True, system_prompt: str | None = None, system_prompt_template: str | None = None, additional_instructions: str | None = None, disallowed_tools: list[str] | None = None, tools_used_names: list[str] | None = None, use_server_manager: bool = False, server_manager: mcp_use.agents.managers.base.BaseServerManager | None = None, verbose: bool = False, pretty_print: bool = False, agent_id: str | None = None, api_key: str | None = None, base_url: str = "https://cloud.mcp-use.com", callbacks: list | None = None, chat_id: str | None = None, retry_on_error: bool = True): ``` ### `method` add\_to\_history Add a message to the conversation history. **Parameters** > The message to add. **Signature** ```python wrap theme={null} def add_to_history(message: langchain_core.messages.base.BaseMessage): ``` ### `method` clear\_conversation\_history Clear the conversation history. **Signature** ```python wrap theme={null} def clear_conversation_history(): ``` ### `method` close Close the MCP connection with improved error handling. **Signature** ```python wrap theme={null} def close(): ``` ### `method` get\_conversation\_history Get the current conversation history. **Returns** > The list of conversation messages. **Signature** ```python wrap theme={null} def get_conversation_history(): ``` ### `method` get\_disallowed\_tools Get the list of tools that are not available to the agent. **Returns** > List of tool names that are not available. **Signature** ```python wrap theme={null} def get_disallowed_tools(): ``` ### `method` get\_system\_message Get the current system message. **Returns** > The current system message, or None if not set. **Signature** ```python wrap theme={null} def get_system_message(): ``` ### `method` initialize Initialize the MCP client and agent. **Signature** ```python wrap theme={null} def initialize(): ``` ### `method` run Run a query using LangChain 1.0.0's agent and return the final result. Example: ```python theme={null} # Regular usage result = await agent.run("What's the weather like?") # Structured output usage from pydantic import BaseModel, Field class WeatherInfo(BaseModel): temperature: float = Field(description="Temperature in Celsius") condition: str = Field(description="Weather condition") weather: WeatherInfo = await agent.run( "What's the weather like?", output_schema=WeatherInfo ) ``` **Parameters** > The query to run. Accepts a plain string or a `HumanMessage` when > Optional maximum number of steps to take. > Whether to handle the connector lifecycle internally. > Optional external history to use instead of the > Optional Pydantic BaseModel class for structured output. **Returns** > The result of running the query as a string, or if output\_schema is provided, an instance of the specified Pydantic model. **Signature** ```python wrap theme={null} def run( query: str | langchain_core.messages.human.HumanMessage, max_steps: int | None = None, manage_connector: bool = True, external_history: list[langchain_core.messages.base.BaseMessage] | None = None, output_schema: type[~T] | None = None ): ``` ### `method` set\_disallowed\_tools Set the list of tools that should not be available to the agent. This will take effect the next time the agent is initialized. **Parameters** > List of tool names that should not be available. **Signature** ```python wrap theme={null} def set_disallowed_tools(disallowed_tools: list[str]): ``` ### `method` set\_system\_message Set a new system message. **Parameters** > The new system message content. **Signature** ```python wrap theme={null} def set_system_message(message: str): ``` ### `method` stream Async generator using LangChain 1.0.0's create\_agent and astream. This method leverages the LangChain 1.0.0 API where create\_agent returns a CompiledStateGraph that handles the agent loop internally via astream. **Tool Updates with Server Manager:** When using server\_manager mode, this method handles dynamic tool updates: * **Before execution:** Updates are applied immediately to the new stream * **During execution:** When tools change, we wait for a "safe restart point" (after tool results complete), then interrupt the stream, recreate the agent with new tools, and resume execution with accumulated messages. * **Safe restart points:** Only restart after tool results to ensure message pairs (tool\_use + tool\_result) are complete, satisfying LLM API requirements. * **Max restarts:** Limited to 3 restarts to prevent infinite loops This interrupt-and-restart approach ensures that tools added mid-execution (e.g., via connect\_to\_mcp\_server) are immediately available to the agent, maintaining the same behavior as the legacy implementation while respecting API constraints. Yields: Intermediate steps and final result from the agent execution. **Parameters** > The query to run. Accepts a plain string or a `HumanMessage` when > Integer value > Whether to handle the connector lifecycle internally. > Optional external history to use instead of the > Boolean flag > Optional Pydantic BaseModel class for structured output. **Returns** > **Signature** ```python wrap theme={null} def stream( query: str | langchain_core.messages.human.HumanMessage, max_steps: int | None = None, manage_connector: bool = True, external_history: list[langchain_core.messages.base.BaseMessage] | None = None, track_execution: bool = True, output_schema: type[~T] | None = None ): ``` ### `method` stream\_events Asynchronous streaming interface. Example:: async for chunk in agent.stream\_events("hello"): print(chunk) **Parameters** > Query string or input > Integer value > Connector instance > List of items **Returns** > **Signature** ```python wrap theme={null} def stream_events( query: str | langchain_core.messages.human.HumanMessage, max_steps: int | None = None, manage_connector: bool = True, external_history: list[langchain_core.messages.base.BaseMessage] | None = None ): ```