Uniwersalny interfejs MCP

MCP (Model Context Protocol) to wiecej niz protokol — to warstwa abstrakcji, ktora fundamentalnie zmienia sposob budowania systemow AI. Jeden otwarty standard laczacy dowolnego agenta z dowolnym zrodlem danych, niezaleznie od frameworka czy dostawcy LLM.

Ewolucja integracji AI

Aby zrozumiec wartosc MCP, warto spojrzec na ewolucje sposobow laczenia agentow AI ze swiatem zewnetrznym:

Architektura MCP

MCP opiera sie na architekturze klient-serwer z jasnym podzialem odpowiedzialnosci:

Korzysci MCP

Korzysc	Opis	Przyklad
Reuzywalnosc	Jeden serwer MCP dziala z Claude, GPT, lokalnymi modelami	Serwer GitHub dziala w Claude Desktop i Cursor IDE
Separacja	Agent nie musi znac szczegolow API	LLM widzi “create_issue(title, body)” bez OAuth flow
Bezpieczenstwo	Izolacja credentials w serwerze	API key nigdy nie trafia do LLM
Ekosystem	2000+ gotowych serwerow (grudzien 2025)	GitHub, Slack, PostgreSQL, Notion, Jira…
Testowalnosc	Serwer testowany niezaleznie od agenta	Unit testy bez mockowania LLM

Ekosystem serwerow MCP (2025)

Stan na grudzien 2025 — ponad 2000 publicznych serwerow MCP. Najpopularniejsze kategorie:

MCP + Frameworki agentowe

MCP nie zastepuje frameworkow — uzupelnia je. Framework zarzadza logika agenta (petle, stan, routing), MCP dostarcza narzedzia do interakcji ze swiatem zewnetrznym.

LangGraph + MCP

# LangGraph z narzedziami MCP
from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Wrapper MCP jako LangChain tool
class MCPToolWrapper:
    def __init__(self, session, tool_name):
        self.session = session
        self.tool_name = tool_name
    
    async def __call__(self, **kwargs):
        result = await self.session.call_tool(
            self.tool_name, 
            arguments=kwargs
        )
        return result.content

# Polaczenie z serwerem MCP
async def create_mcp_tools():
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@modelcontextprotocol/server-github"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # Pobierz liste narzedzi
            tools = await session.list_tools()
            
            # Stworz wrappery
            return [
                MCPToolWrapper(session, tool.name) 
                for tool in tools.tools
            ]

# Uzycie w LangGraph
async def build_graph():
    mcp_tools = await create_mcp_tools()
    
    workflow = StateGraph(AgentState)
    workflow.add_node("agent", agent_node)
    workflow.add_node("tools", ToolNode(mcp_tools))
    
    workflow.add_edge(START, "agent")
    workflow.add_conditional_edges("agent", should_continue)
    workflow.add_edge("tools", "agent")
    
    return workflow.compile()

CrewAI + MCP

# CrewAI z narzedziami MCP
from crewai import Agent, Task, Crew
from crewai.tools import BaseTool
from mcp import ClientSession

class GitHubMCPTool(BaseTool):
    name: str = "github_issues"
    description: str = "List and create GitHub issues"
    
    def _run(self, action: str, **kwargs) -> str:
        # Synchroniczny wrapper na async MCP
        import asyncio
        return asyncio.run(self._async_run(action, **kwargs))
    
    async def _async_run(self, action: str, **kwargs):
        async with ClientSession(transport) as session:
            result = await session.call_tool(
                f"github_{action}",
                arguments=kwargs
            )
            return result.content

# Agent z MCP tool
developer = Agent(
    role="Senior Developer",
    goal="Manage GitHub issues efficiently",
    tools=[GitHubMCPTool()],
    llm="gpt-4o"
)

task = Task(
    description="Review open issues and prioritize them",
    agent=developer
)

crew = Crew(agents=[developer], tasks=[task])
result = crew.kickoff()

OpenAI Agents SDK + MCP

# OpenAI Agents SDK z MCP
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Natywna integracja MCP w Agents SDK!
github_server = MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
    env={"GITHUB_TOKEN": os.getenv("GITHUB_TOKEN")}
)

filesystem_server = MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/workspace"]
)

# Agent z wieloma serwerami MCP
agent = Agent(
    name="DevOps Assistant",
    instructions="Help with code reviews and file management",
    mcp_servers=[github_server, filesystem_server]
)

# Uruchomienie
async with Runner.run(agent) as runner:
    result = await runner.run(
        "List open PRs and save summary to /workspace/pr-report.md"
    )

Wzorce architektoniczne

1. Gateway Pattern

Jeden “super-serwer” MCP agregujacy wiele serwerow:

# MCP Gateway - agreguje wiele serwerow
from mcp.server import Server
from mcp import ClientSession

class MCPGateway:
    def __init__(self):
        self.server = Server("gateway")
        self.backends = {}  # nazwa -> ClientSession
    
    async def register_backend(self, name: str, session: ClientSession):
        self.backends[name] = session
        
        # Eksponuj narzedzia backend'u z prefixem
        tools = await session.list_tools()
        for tool in tools.tools:
            self._register_proxied_tool(name, tool)
    
    def _register_proxied_tool(self, backend: str, tool):
        @self.server.tool(name=f"{backend}_{tool.name}")
        async def proxy(**kwargs):
            return await self.backends[backend].call_tool(
                tool.name, arguments=kwargs
            )

2. Sidecar Pattern

Serwer MCP jako sidecar container w Kubernetes:

# kubernetes deployment z MCP sidecar
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: agent
        image: my-agent:latest
        
      - name: mcp-postgres
        image: mcp/server-postgres:latest
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              
      - name: mcp-slack
        image: mcp/server-slack:latest

Wyzwania i rozwiazania

Wyzwanie	Rozwiazanie
Autentykacja	OAuth proxy, secrets w env vars, HashiCorp Vault
Discovery	Registry serwerow (planowane), DNS-SD
Wersjonowanie	Semantic versioning, capability negotiation
Rate limiting	Implementacja w serwerze, circuit breaker
Observability	OpenTelemetry, structured logging

Przyszlosc MCP

Jak zaczac?