> ## Documentation Index
> Fetch the complete documentation index at: https://mcp-use.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

<AgentInstructions>

## Submitting Feedback

If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:

POST https://mcp-use.com/docs/feedback

```json
{
  "path": "/typescript/agent/agent-configuration",
  "feedback": "Description of the issue"
}
```

Only submit feedback when you have something specific and actionable to report.

</AgentInstructions>

# Configuration

> Configure your agents and LLM settings

export const CodeSandbox = ({title, id}) => {
  return <a href={`https://codesandbox.io/p/devbox/${id}?embed=1`}>
        <img noZoom src={`https://codesandbox.io/static/img/play-codesandbox.svg`} alt={title} />
    </a>;
};

Configure your MCPAgent to customize behavior, set LLM parameters, enable features, and optimize for your specific use case. This guide covers all configuration options available when creating and running agents.

<Info>
  **Looking for client configuration?** This guide covers agent-specific configuration. For MCP client and server connection setup, see the [Client Configuration](/typescript/client/client-configuration) guide.
</Info>

## Basic Configuration

Create an agent with minimal configuration:

```typescript theme={null}
import { MCPAgent, MCPClient } from 'mcp-use'
import { ChatOpenAI } from '@langchain/openai'

const client = new MCPClient({
  mcpServers: {
    filesystem: {
      command: 'npx',
      args: ['-y', '@modelcontextprotocol/server-filesystem', './']
    }
  }
})
await client.createAllSessions()

const llm = new ChatOpenAI({ model: 'gpt-5.1' })

const agent = new MCPAgent({
  llm,
  client
})
```

<CodeSandbox title="Edit mcp-use-get-started-agent" id="sweet-drake-m76ys6" />

## Agent Parameters

When creating an MCPAgent, you can configure several parameters to customize its behavior:

<CodeGroup>
  ```typescript TypeScript theme={null}
  // Advanced configuration
  const advancedAgent = new MCPAgent({
      llm: new ChatOpenAI({ model: 'gpt-4o', temperature: 0.7 }),
      client: new MCPClient(config),
      maxSteps: 30,
      autoInitialize: true,
      memoryEnabled: true,
      systemPrompt: 'Custom instructions for the agent',
      additionalInstructions: 'Additional guidelines for specific tasks',
      disallowedTools: ['file_system', 'network', 'shell']  // Restrict potentially dangerous tools
  })
  ```
</CodeGroup>

### Available Parameters

* `llm`: Any LangChain-compatible language model (required)
* `client`: The MCPClient instance (optional if connectors are provided)
* `connectors`: List of connectors if not using client (optional)
* `maxSteps`: Maximum number of steps the agent can take (default: 5)
* `autoInitialize`: Whether to initialize automatically (default: false)
* `memoryEnabled`: Whether to enable memory (default: true)
* `systemPrompt`: Custom system prompt (optional)
* `systemPromptTemplate`: Custom system prompt template (optional)
* `additionalInstructions`: Additional instructions for the agent (optional)
* `disallowedTools`: List of tool names that should not be available to the agent (optional)
* `useServerManager`: Enable dynamic server selection (default: false)

## Tool Access Control

You can restrict which tools are available to the agent for security or to limit its capabilities. Here's a complete example showing how to set up an agent with restricted tool access:

<CodeGroup>
  ```typescript TypeScript theme={null}
  ...
  // mcp sevrers with filesystem, network, shell, and database

  const agent = new MCPAgent({
    llm,
    client,
    disallowedTools: ['file_system', 'network', 'shell', 'database']
  })

  ...

  ```
</CodeGroup>

You can also manage tool restrictions dynamically:

<CodeGroup>
  ```typescript TypeScript theme={null}
  // Update restrictions after initialization
  agent.setDisallowedTools(['file_system', 'network', 'shell', 'database'])
  await agent.initialize()  // Reinitialize to apply changes

  // Check current restrictions
  const restrictedTools = agent.getDisallowedTools()
  console.log(`Restricted tools: ${restrictedTools}`)
  ```
</CodeGroup>

## Server Manager

The Server Manager is an agent-level feature that enables dynamic server selection for improved performance with multi-server setups.

To improve efficiency and potentially reduce agent confusion when many tools are available, you can enable the Server Manager by setting `useServerManager: true` when creating the `MCPAgent`.

```typescript theme={null}
// Enable server manager for automatic server selection
const agent = new MCPAgent({
    llm,
    client,
    useServerManager: true  // Enable dynamic server selection
})
```

For more details on server manager implementation, see the [Server Manager](./server-manager) guide.

## Memory

MCPAgent supports conversation memory to maintain context across interactions:

```typescript theme={null}
// Enable memory (default)
const agent = new MCPAgent({
    llm,
    client,
    memoryEnabled: true
})

// Disable memory for stateless interactions
const statelessAgent = new MCPAgent({
    llm,
    client,
    memoryEnabled: false
})
```

For more details on memory management, see the [Memory Management](/typescript/agent/memory-management) guide.

## System Prompt

You can customize the agent's behavior through system prompts:

```typescript theme={null}
const customPrompt = `
You are a helpful assistant specialized in data analysis.
Always provide detailed explanations for your reasoning.
When working with data, prioritize accuracy over speed.
`

const agent = new MCPAgent({
    llm,
    client,
    systemPrompt: customPrompt
})
```

## Next Steps

* [Memory Management](/typescript/agent/memory-management)
* [Server Manager](/typescript/agent/server-manager)