flowchart LR
    MC[MCP Client] -->|MCP Protocol| B[AgentToolsServer]
    A2A[A2A Client] -->|message/send| AD[A2A Adapter]
    AD -->|tools/call| B
    B --> C[ToolRegistry]
    C --> D[AgentLoop]
    D -->|OpenRouter| E[LLM]
    D -->|callTool| F[ToolClient]
    D -->|discover| G[A2A Discovery]
    F --> H[FlowMCP Schemas]
    H --> I[External APIs]

git clone https://github.com/FlowMCP/mcp-agent-server.git
cd mcp-agent-server
npm i

import express from 'express'
import { AgentToolsServer } from 'mcp-agent-server'

const app = express()
app.use( express.json() )

const { mcp } = await AgentToolsServer.create( {
    name: 'My Agent Server',
    version: '1.0.0',
    routePath: '/mcp',
    llm: {
        baseURL: 'https://openrouter.ai/api',
        apiKey: process.env.OPENROUTER_API_KEY
    },
    tools: [
        {
            name: 'defi-research',
            description: 'Research DeFi protocols',
            inputSchema: {
                type: 'object',
                properties: {
                    query: { type: 'string' }
                },
                required: [ 'query' ]
            },
            agent: {
                systemPrompt: 'You are a DeFi research agent.',
                model: 'anthropic/claude-sonnet-4-6',
                maxRounds: 10,
                maxTokens: 4096
            },
            toolSources: [
                {
                    type: 'flowmcp',
                    schemas: [ defilamaSchema, coingeckoSchema ],
                    serverParams: { DEFILAMA_KEY: process.env.DEFILAMA_KEY }
                }
            ],
            execution: {
                taskSupport: 'optional'
            }
        }
    ]
} )

app.use( mcp.middleware() )
app.listen( 4100 )

AgentToolsServer.create( { name, version, routePath, llm, tools, tasks } )

// AgentToolsServer instance
const { mcp } = await AgentToolsServer.create( { /* config */ } )

AgentToolsServer.fromManifest( { manifest, llm, schemas, serverParams, routePath } )

import { agent } from './agent.mjs'

const { mcp } = await AgentToolsServer.fromManifest( {
    manifest: agent,
    llm: {
        baseURL: 'https://openrouter.ai/api',
        apiKey: process.env.OPENROUTER_API_KEY
    },
    schemas: [ etherscanSchema, defilamaSchema ],
    serverParams: { ETHERSCAN_API_KEY: process.env.ETHERSCAN_API_KEY }
} )

mcp.middleware()

// Express middleware function (req, res, next) => Promise<void>
app.use( mcp.middleware() )

mcp.listToolDefinitions()

const { tools } = mcp.listToolDefinitions()
// tools: [ { name, description, inputSchema, execution? } ]

import { AgentToolsServer } from 'mcp-agent-server'
import { A2AAdapter } from 'mcp-agent-server/a2a'

const { mcp } = await AgentToolsServer.fromManifest( { manifest, llm: { ... } } )

app.use( mcp.middleware() )

// A2A (optional)
const a2a = A2AAdapter.from( { mcp, manifest, serverUrl: 'https://my-agent.com' } )
app.use( '/.well-known/agent.json', a2a.agentCardMiddleware() )
app.use( '/a2a/v1', a2a.handler() )

const { mcp } = await AgentToolsServer.fromManifest( {
    manifest,
    llm: { ... },
    discovery: true    // Enables discover_agent tool
} )

import express from 'express'
import { X402Middleware } from 'x402-mcp-middleware/v2'
import { AgentToolsServer } from 'mcp-agent-server'

const app = express()
app.use( express.json() )

// 1. Payment gate (optional)
const x402 = await X402Middleware.create( { /* config */ } )
app.use( x402.mcp() )

// 2. Agent MCP Server
const { mcp } = await AgentToolsServer.create( { /* config */ } )
app.use( mcp.middleware() )

app.listen( 4100 )