Building MCP Clients

import asyncio
import sys

from mcp import Client, StdioServerParameters


async def main() -> None:
    # stdio: the SDK spawns the server as a subprocess; pass a URL string instead for Streamable HTTP
    server = StdioServerParameters(command=sys.executable, args=["server.py"])
    async with Client(server) as client:
        print(client.protocol_version)                            # 2026-07-28, learned via server/discover
        tools = await client.list_tools()                         # tools/list
        print([t.name for t in tools.tools])
        result = await client.call_tool(                          # tools/call
            "search_docs", {"query": "matrix", "component": "algebra", "top_k": 1})
        print(result.is_error, result.structured_content["hits"][0]["page"])
        page = await client.read_resource("docs://algebra/matrices")         # resources/read
        print(page.contents[0].text[:40])
        prompt = await client.get_prompt("answer_with_citations",            # prompts/get
                                         {"question": "How do I solve Ax=b?"})
        print(prompt.messages[0].content.text[:50])


asyncio.run(main())

import asyncio

from langchain_mcp_adapters.client import MultiServerMCPClient


async def main() -> None:
    client = MultiServerMCPClient(
        {
            "docs": {"transport": "streamable_http", "url": "http://127.0.0.1:8000/mcp"},
            "docs-local": {"transport": "stdio", "command": "python", "args": ["server.py"]},
        },
        tool_name_prefix=True,  # avoid collisions: docs_search_docs, docs-local_search_docs
    )
    tools = await client.get_tools(server_name="docs")
    print([t.name for t in tools])
    result = await tools[0].ainvoke({"query": "matrix", "component": "algebra", "top_k": 1})
    print(result)


asyncio.run(main())

import asyncio

from langchain.agents import create_agent
from langchain_mcp_adapters.callbacks import Callbacks
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_ollama import ChatOllama
from mcp.types import ElicitResult


async def on_elicitation(mcp_context, params, context) -> ElicitResult:
    # v1 SDK connection: the server sends elicitation/create itself; answer it (here: always "algebra")
    print("server asks:", params.message)
    return ElicitResult(action="accept", content={"component": "algebra"})


async def main() -> None:
    client = MultiServerMCPClient(
        {"docs": {"transport": "streamable_http", "url": "http://127.0.0.1:8000/mcp"}},
        callbacks=Callbacks(on_elicitation=on_elicitation),
    )
    tools = await client.get_tools()
    agent = create_agent(ChatOllama(model="llama3.1:8b"), tools)
    out = await agent.ainvoke({"messages": [{"role": "user", "content": "How do I solve a linear system?"}]})
    print(out["messages"][-1].content)


asyncio.run(main())

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>2.0.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-mcp-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-ollama</artifactId>
    </dependency>
</dependencies>

spring.ai.mcp.client.type=SYNC
spring.ai.mcp.client.request-timeout=30s
spring.ai.mcp.client.streamable-http.connections.docs.url=http://127.0.0.1:8080
spring.ai.mcp.client.streamable-http.connections.docs.endpoint=/mcp
spring.ai.ollama.chat.options.model=llama3.1:8b

@SpringBootApplication
public class DocsClientApplication {

    public static void main(String[] args) {
        SpringApplication.run(DocsClientApplication.class, args);
    }

    @Bean
    CommandLineRunner listAndCall(ToolCallbackProvider tools) {
        return args -> {
            for (ToolCallback callback : tools.getToolCallbacks()) {
                System.out.println(callback.getToolDefinition().name());
            }
            ToolCallback search = tools.getToolCallbacks()[0];
            System.out.println(search.call("{\"query\":\"matrix\",\"component\":\"algebra\",\"topK\":1}"));
        };
    }

    // With any ChatModel (here the Ollama starter), the MCP tools become model tools.
    static String ask(ChatModel chatModel, ToolCallbackProvider tools, String question) {
        return ChatClient.create(chatModel)
                .prompt(question)
                .toolCallbacks(tools)
                .call()
                .content();
    }
}

@Component
class DocsElicitation {

    @McpElicitation(clients = "docs")
    ElicitResult onElicit(ElicitRequest request) {
        return new ElicitResult(ElicitResult.Action.ACCEPT, Map.of("component", "algebra"));
    }
}

McpTransport transport = StreamableHttpMcpTransport.builder()
        .url("http://127.0.0.1:8080/mcp")
        .timeout(Duration.ofSeconds(20))
        .build();
try (McpClient client = DefaultMcpClient.builder().key("docs").transport(transport).build()) {
    client.listTools().forEach(t -> System.out.println(t.name()));
    ToolExecutionResult result = client.executeTool(ToolExecutionRequest.builder()
            .name("search_docs")
            .arguments("{\"query\":\"matrix\",\"component\":\"algebra\",\"topK\":1}")
            .build());
    System.out.println(result.resultText());
    // AiServices.builder(Assistant.class).chatModel(model).toolProvider(provider).build()
    McpToolProvider provider = McpToolProvider.builder().mcpClients(client).build();
}

import asyncio

import mcp_types as types
from mcp import Client
from mcp.client.session import ClientRequestContext


async def choose(context: ClientRequestContext, params: types.ElicitRequestParams) -> types.ElicitResult:
    print("server asks:", params.message)
    return types.ElicitResult(action="accept", content={"component": "algebra"})


async def main() -> None:
    async with Client("http://127.0.0.1:8000/mcp", elicitation_callback=choose) as client:
        result = await client.call_tool("search_docs", {"query": "matrix"})
        print(result.structured_content["component"], len(result.structured_content["hits"]))


asyncio.run(main())

import asyncio

import mcp_types as types
from mcp import Client
from mcp.client.session import ClientRequestContext


async def ask_user(context: ClientRequestContext, params: types.ElicitRequestParams) -> types.ElicitResult:
    # Passing a callback is what declares the elicitation capability; the manual loop below answers itself.
    return types.ElicitResult(action="decline")


async def main() -> None:
    async with Client("http://127.0.0.1:8000/mcp", elicitation_callback=ask_user) as client:
        args = {"query": "matrix"}
        outcome = await client.session.call_tool("search_docs", args, allow_input_required=True)
        if isinstance(outcome, types.InputRequiredResult):
            print("input required:", list(outcome.input_requests or {}))
            answers = {key: types.ElicitResult(action="accept", content={"component": "algebra"})
                       for key in (outcome.input_requests or {})}
            outcome = await client.session.call_tool(
                "search_docs", args, input_responses=answers, request_state=outcome.request_state,
                allow_input_required=True)
        print(outcome.structured_content["component"])


asyncio.run(main())

import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';

const client = new Client(
    { name: 'docs-client', version: '1.0.0' },
    {
        capabilities: { elicitation: { form: {} } },
        versionNegotiation: { mode: 'auto' } // probe server/discover, fall back to initialize
    }
);

// The same handler serves 2026-07-28 input_required rounds and 2025-11-25 elicitation/create requests.
client.setRequestHandler('elicitation/create', async request => {
    console.log('server asks:', request.params.message);
    return { action: 'accept', content: { component: 'algebra' } };
});

await client.connect(new StreamableHTTPClientTransport(new URL('http://127.0.0.1:3000/mcp')));
const result = await client.callTool({ name: 'search_docs', arguments: { query: 'matrix' } });
console.log(JSON.stringify(result.structuredContent));
await client.close();

import {
    Client,
    StreamableHTTPClientTransport,
    isInputRequiredResult,
    withInputRequired,
    type InputResponses
} from '@modelcontextprotocol/client';
import * as z from 'zod/v4';

const client = new Client(
    { name: 'docs-client', version: '1.0.0' },
    {
        capabilities: { elicitation: { form: {} } },
        versionNegotiation: { mode: 'auto' },
        inputRequired: { autoFulfill: false } // manual mode
    }
);
await client.connect(new StreamableHTTPClientTransport(new URL('http://127.0.0.1:3000/mcp')));

const callSchema = withInputRequired(z.object({ structuredContent: z.unknown().optional() }).loose());
const params = { name: 'search_docs', arguments: { query: 'matrix' } };
let outcome = await client.request({ method: 'tools/call', params }, callSchema, { allowInputRequired: true });
if (isInputRequiredResult(outcome)) {
    const inputResponses: InputResponses = {};
    for (const [key, req] of Object.entries(outcome.inputRequests ?? {})) {
        console.log('asked', key, req.method);
        inputResponses[key] = { action: 'accept', content: { component: 'algebra' } };
    }
    outcome = await client.request(
        { method: 'tools/call', params: { ...params, inputResponses, requestState: outcome.requestState } },
        callSchema,
        { allowInputRequired: true }
    );
}
console.log(JSON.stringify(outcome));
await client.close();