Salt la conținutul principal
Română— Alege o limbă
Meniu

MCP și Conectori: Conectarea la Servicii Externe

Lecția 9 din 25 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. MCP și Conectori: Conectarea la Servicii Externe
  2. Ce este MCP?
  3. Conectarea unui Server MCP
  4. Servere MCP la Distanță prin SSE
  5. Conectori OpenAI
  6. Combinarea MCP cu Instrumente de Tip Funcție
  7. Filtrarea Instrumentelor MCP
  8. Gestionarea Erorilor MCP
  9. Puncte cheie

Actualizat pe 2 noiembrie 2026 — Agent Builder. Pe 3 iunie 2026, OpenAI a anunțat închiderea Agent Builder, programată pentru 30 noiembrie 2026; ChatKit rămâne disponibil. În viitor, OpenAI direcționează utilizatorii către SDK-ul Agents sau agenții din spațiul de lucru ChatGPT. Începând cu 10 septembrie 2026, OpenAI oferă o versiune beta publică a API-ului Agents care găzduiește orchestrarea agenților (vezi ChatGPT în 2026, Lecția 10).

MCP și Conectori: Conectarea la Servicii Externe

Protocolul de Context al Modelului (MCP) este un standard deschis care permite agentului dumneavoastră să se conecteze la servicii externe într-un mod standardizat. În loc să rescrieți integrări pentru fiecare serviciu, conectați un server MCP, iar agentul dumneavoastră dobândește instantaneu noi instrumente. Acolo unde ați fi scris trei sute de linii de cod client GitHub, acum aveți nevoie doar de o singură declarație de server.

Ce este MCP?

MCP este un standard deschis care definește modul în care un client—agentul dumneavoastră—comunică cu un server, adică un serviciu extern. Fiecare server MCP expune instrumente pe care agentul dumneavoastră le poate utiliza. Protocolul gestionează transportul, serializarea și descoperirea instrumentelor. Această ultimă caracteristică este cea mai valoroasă pentru activitatea zilnică: agentul interoghează serverul pentru a vedea ce poate face, astfel încât nu trebuie să mențineți o listă manual. SDK-ul Agents include suport nativ pentru MCP și se conectează la orice server compatibil.

Conectarea unui Server MCP

SDK-ul oferă clasa MCPServerStdio pentru serverele locale care comunică prin stdin/stdout—de obicei un proces Node lansat cu npx.

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Server MCP local (comunică prin stdin/stdout)
file_server = MCPServerStdio(
    name="File Manager",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/folder"],
)

async def main():
    async with file_server:
        agent = Agent(
            name="File Agent",
            instructions="You manage files for the user.",
            mcp_servers=[file_server],
        )
        result = await Runner.run(agent, "List the files in the root folder.")
        print(result.final_output)

Blocul async with nu este doar o decorare: acesta pornește procesul serverului, descoperă instrumentele sale și îl oprește corect când blocul se încheie. Un agent creat în afara acestui context nu va avea niciun instrument.

Servere MCP la Distanță prin SSE

Pentru serverele găzduite, utilizați MCPServerSse și transportul SSE (Server-Sent Events). Logica rămâne aceeași; se schimbă doar URL-ul și anteturile de autentificare.

from agents.mcp import MCPServerSse

github_server = MCPServerSse(
    name="GitHub",
    url="https://mcp.github.com/sse",
    headers={"Authorization": "Bearer ghp_your_token"},
)

async def main():
    async with github_server:
        agent = Agent(
            name="DevOps Agent",
            instructions="You manage GitHub repositories.",
            mcp_servers=[github_server],
        )
        result = await Runner.run(
            agent,
            "Create an issue in the my-project repo with the title 'Critical Bug'"
        )
        print(result.final_output)

Conectori OpenAI

Pe lângă MCP, OpenAI oferă conectori gestionați direct pe platformă. Aceștia se integrează în Agent Builder și rămân utilizabili prin SDK fără a necesita găzduirea unui server de către dumneavoastră.

from agents import Agent, Runner

# Conectorii configurați în Agent Builder sunt disponibili automat
agent = Agent(
    name="CRM Agent",
    instructions="""You are a CRM assistant. Use the connectors
    to access Salesforce, HubSpot, and Google Workspace.""",
    model="gpt-5.6-terra",
    # Conectorii sunt legați de configurația agentului pe platformă
)

Absența parametrului mcp_servers are sens: conectorii sunt legați de configurația agentului pe platformă. Aceștia gestionează pentru dumneavoastră autentificarea OAuth, paginarea și limitarea ratei—trei aspecte care consumă timp semnificativ atunci când sunt gestionate manual.

Combinarea MCP cu Instrumente de Tip Funcție

Nu trebuie să alegeți între ele. Un singur agent poate utiliza un server MCP pentru accesul la date și propriile dumneavoastră funcții pentru logica de afaceri pe care nu doriți să o delegați.

from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio

@function_tool
def calculate_invoice(amount_excl_tax: float, vat_rate: float = 20.0) -> str:
    """Calculates the total amount including tax for an invoice."""
    amount_incl_tax = amount_excl_tax * (1 + vat_rate / 100)
    return f"Excl. tax: €{amount_excl_tax}, VAT {vat_rate}%: €{amount_excl_tax * vat_rate / 100:.2f}, Incl. tax: €{amount_incl_tax:.2f}"

db_server = MCPServerStdio(
    name="Database",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"],
)

async def main():
    async with db_server:
        agent = Agent(
            name="Accounting Agent",
            instructions="""You handle accounting.
            Use the database for customer data
            and the calculation function for invoices.""",
            tools=[calculate_invoice],
            mcp_servers=[db_server],
        )
        result = await Runner.run(
            agent,
            "Retrieve orders for customer Alice and calculate the total invoice"
        )
        print(result.final_output)

Calculul TVA rămâne în codul dumneavoastră, unde este testabil și auditabil; preluarea comenzilor trece prin serverul MCP PostgreSQL. Aceasta este separarea pe care ar trebui să o vizați.

Filtrarea Instrumentelor MCP

Un server MCP poate expune zeci de instrumente, dintre care majoritatea nu vor conta pentru cazul dumneavoastră de utilizare—iar fiecare consumă context și crește riscul unui apel inadecvat. Începeți prin a inspecta ce este disponibil efectiv.

server = MCPServerStdio(
    name="GitHub",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
)

# Puteți filtra în timpul conexiunii
async with server:
    tools = await server.list_tools()
    # Inspectați instrumentele disponibile
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

Gestionarea Erorilor MCP

Un server MCP este un proces sau un serviciu la distanță: acesta poate eșua la pornire, își poate pierde conexiunea sau poate avea un token expirat. Planificați un mod degradat în loc să lăsați excepția să urce până la utilizator.

from agents.mcp import MCPServerStdio

async def create_agent_with_mcp():
    server = MCPServerStdio(
        name="External Service",
        command="npx",
        args=["-y", "my-mcp-server"],
    )

    try:
        async with server:
            agent = Agent(
                name="My Agent",
                instructions="Use the external service.",
                mcp_servers=[server],
            )
            result = await Runner.run(agent, "Execute the task.")
            return result.final_output
    except Exception as e:
        # Fallback fără MCP
        fallback_agent = Agent(
            name="My Agent (degraded mode)",
            instructions="The external service is unavailable. Inform the user.",
        )
        result = await Runner.run(fallback_agent, "The service is unavailable.")
        return result.final_output

Agentul de rezervă (fallback) nu pretinde că funcționează: acesta anunță indisponibilitatea. Un agent care inventează un răspuns când sursa sa de date este inaccesibilă costă mult mai mult decât unul care admite că nu poate continua.

Puncte cheie

  • MCP este un protocol deschis pentru conectarea serviciilor externe la agentul dumneavoastră
  • Utilizați MCPServerStdio pentru servere locale și MCPServerSse pentru servere la distanță
  • Conectorii OpenAI sunt integrări gestionate pe platformă
  • Puteți combina instrumente de tip funcție și servere MCP în același agent
  • Gestionați erorile de conexiune MCP cu un mod degradat