MCP Client

gllm-tools | Tutorial: Model Context Protocol

Model Context Protocol (MCP) Integration

One of the primary tools in this library is the MCP client, which connects to Model Context Protocol servers. MCP is an open standard that defines how LLMs communicate with external data sources and services. Think of MCP as a universal adapter—it standardizes the way models request and receive information from various sources, whether that's databases, APIs, file systems, or specialized tools.

The relationship is straightforward: Tools are what LLMs use to interact with the world, and MCP is the protocol that standardizes how those interactions happen.

Framework-Agnostic Design

A key advantage of this MCP client implementation is its framework-agnostic architecture. Unlike solutions tied to specific platforms, this tool provides direct connectivity to any MCP server and can be easily integrated into any agentic framework, including:

• LangGraph - For building stateful, multi-actor applications

• Google ADK - For Google's agent development toolkit

• CrewAI - For orchestrating role-playing AI agents

• AutoGen, Haystack, or any custom framework

This flexibility means you can leverage MCP's standardized server ecosystem regardless of your chosen development stack, avoiding vendor lock-in and maintaining portability across different AI architectures.

Pre-Requisites

• Python 3.11+

• Python package manager (pip, poetry, uv)

Setting Up

1

Installation

pip

pip install gllm-tools

poetry

uv

2

Set up the Client

from gllm_tools.mcp.client.config import MCPConfiguration

# Configure your MCP servers
servers = {
    "github": {
        "url": "https://api.githubcopilot.com/mcp",
        "headers": {
            "Authorization": "Bearer {gho_token}"
        }
    }
}

# Create the client
client = MCPClient(servers)

3

List all Tools

import asyncio

# client = MCPClient(servers) from Step 2
async def use_tools():
    # Get all available tools
    tools = await client.get_tools()
    print(f"Available tools: {[tool.name for tool in tools]}")
    
    # Get tools from a specific server
    github_tools = await client.get_tools(server="github")
    
    # Tools are MCPTool objects with name, description, and parameters
    for tool in github_tools:
        print(f"Tool: {tool.name}")
        print(f"Description: {tool.description}")
        print(f"Parameters: {tool.parameters}")

asyncio.run(use_tools())

4

Executing a Tool Directly

Note that this example is purely for example. It is not recommended to utilize MCP tools this way; it is only to demonstrate how to use tools directly. For programmatic purposes, it is highly recommended to use REST API or SDK instead!

MCP is intended for LLMs and AI Agents! See section Working with other Agentic Frameworks to utilize MCP in the appropriate context!

import asyncio
from typing import cast
from mcp import ClientSession
from gllm_tools.mcp.client.session import create_session

configuration = {
    "github": {
        "url": "https://api.githubcopilot.com/mcp",
        "headers": {
            "Authorization": "Bearer {gho_token}"
        }
    }
}

async def main():
    async with create_session(configuration) as session:
        await session.initialize()
        tool_name = "github_get_issue_handler"
        params = {
            "owner": "gdp-admin",
            "repo": "gl-sdk",
            "issue_number": 2668,
        }
        call_tool_result = await cast(ClientSession, session).call_tool(tool_name, params)
        print(call_tool_result)

if __name__ == "__main__":
    asyncio.run(main())

Working with other Agentic Frameworks

Langgraph

We have provided a LangchainMCPClient that adapts MCP for specific agentic frameworks. Here is an example of implementing an Agent using Langgraph utilizing our MCP Client. The complete source code can be found here.

from gllm_tools.mcp.client.langchain.client import LangchainMCPClient
from langgraph.prebuilt import create_react_agent

# Same server configuration
servers = {"github": {...}}

# Langchain-specific client (this is a framework adapter!)
langchain_client = LangchainMCPClient(servers)

# Get Langchain-compatible tools
tools = await langchain_client.get_tools()

agent = create_react_agent(
    name="HelloAgent",
    prompt="You are a helpful assistant that can utilize all tools given to you to solve the user's input.",
    model=ChatOpenAI("gpt-4.1"),
    tools=tools,
)

Others

The base MCPClient is framework-agnostic and returns raw MCPTool object. To integrate with specific agentic frameworks (like Langchain, CrewAI, Google ADK, etc.), you extend the client to create framework adapters that allow other agentic frameworks to connect to MCP servers. Please refer to the Langgraph section above to see a full complete adapter.

from gllm_tools.mcp.client.client import MCPClient

class MyAgenticFrameworkClient(MCPClient):
    async def _process_tool(self, tool, config):
        """Convert MCPTool to your framework's tool format."""
        # Convert to your framework's tool format
        return MyFrameworkTool(
            name=tool.name,
            description=tool.description,
            schema=tool.parameters,
            # Add framework-specific execution logic
        )

# Usage
client = MyAgenticFrameworkClient(servers)
tools = await client.get_tools()  # Returns MyFrameworkTool objects