Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

MCP en ingebouwde tools combineren

Les 10 van 12 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Twee tool-families, één catalogus
  2. Mengsel: niets extra’s te leren
  3. Orkestratie gebeurt automatisch
  4. Twee typische samenstellingen
  5. De verborgen kosten van overvloed
  6. Belangrijkste punten

Twee tool-families, één catalogus

MCP is niet de enige manier om Grok extra mogelijkheden te geven. De xAI-API bevat ook native tools, zogenaamde ingebouwde tools, die het model kan aanroepen zonder tussenkomst van een externe server. U hoeft niet te kiezen tussen deze twee families: u declareert ze op dezelfde plek en combineert ze vrijelijk in één enkele configuratie.

Vier native tools dekken de meeste behoeften.

  • Web search: realtime zoekopdrachten op het web
  • Code execution: uitvoeren van Python-code in een sandbox
  • Image analysis: analyse en beschrijving van afbeeldingen
  • File parsing: lezen en extraheren van bestandsinhoud

U declareert ze in de tools-array alleen op basis van hun type, zonder URL of label. Dat is logisch, aangezien er geen externe server is om aan te wijzen.

Mengsel: niets extra’s te leren

De syntaxe vereist geen speciale constructies. U plaatst MCP-objecten en native objecten gewoon naast elkaar in dezelfde array.

from xai_sdk import Client
from xai_sdk.tools import mcp

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(
    model="grok-4.20-0309-reasoning",
    tools=[
        # Remote MCP tool
        mcp(
            server_url="https://mcp.deepwiki.com/mcp",
            server_label="deepwiki",
            server_description="Documentation for GitHub projects"
        ),
        # Native tool: web search
        {"type": "web_search"},
    ],
)

De Responses API in OpenAI-formaat volgt dezelfde logica, waarbij de MCP-tool eenvoudigweg zijn getypeerde dictionary-vorm aanneemt.

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input=[{"role": "user", "content": "Compare React and Vue based on the official docs and current trends"}],
    tools=[
        {
            "type": "mcp",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "server_label": "deepwiki"
        },
        {"type": "web_search"},
    ],
)

Orkestratie gebeurt automatisch

Vanuit het perspectief van het model vormen MCP- en native tools één enkele catalogus. Grok maakt geen onderscheid tussen een tool die via het netwerk naar een server van derden gaat en een tool die door de xAI-infrastructuur wordt uitgevoerd: het ziet mogelijkheden, met namen en beschrijvingen, en selecteert degene die de respons op elk moment het beste vooruit helpt.

Neem de query “vergelijk de routing-configuratie in Next.js met de huidige best practices”. Grok roept eerst deepwiki__search aan om de routing-documentatie in de Next.js-repository te lezen, vervolgens web_search om recente artikelen over huidige praktijken te vinden, en synthetiseert ten slotte beide bronnen tot een coherente respons. Op geen enkel moment heeft u deze volgorde gespecificeerd, of zelfs maar aangegeven dat deze twee tools samen gebruikt moesten worden. Het model beslist zelf over de volgorde en u hoeft geen orkestratielogica te schrijven.

Twee typische samenstellingen

Een technische research-agent maakt gebruik van referentiedocumentatie, webtoegang en mogelijkheden voor codeverificatie.

tools = [
    mcp(
        server_url="https://mcp.deepwiki.com/mcp",
        server_label="deepwiki",
        server_description="Documentation and source code for GitHub projects"
    ),
    {"type": "web_search"},
    {"type": "code_interpreter"},
]

Met dit trio kunt u projectdocumentatie raadplegen, online zoeken naar aanvullende informatie en vervolgens code uitvoeren om een oplossing te valideren voordat u deze voorstelt. De derde tool verandert de aard van de respons: in plaats van te beweren dat een fragment werkt, verifieert de agent dit daadwerkelijk.

Een interne technische assistent volgt een andere logica, waarbij twee private servers de kennis van het bedrijf bevatten en het web alleen als back-up dient.

tools = [
    mcp(
        server_url="https://kb.monentreprise.com/mcp",
        server_label="kb",
        server_description="Internal knowledge base",
        authorization=f"Bearer {os.getenv('KB_TOKEN')}"
    ),
    mcp(
        server_url="https://jira.monentreprise.com/mcp",
        server_label="jira",
        server_description="Jira tickets and projects",
        authorization=f"Bearer {os.getenv('JIRA_TOKEN')}",
        allowed_tool_names=["search_issues", "get_issue"]
    ),
    {"type": "web_search"},
]

De assistent doorzoekt de kennisbank, raadpleegt gerelateerde Jira-tickets en vult dit aan met een webzoekopdracht als informatie intern ontbreekt. Let op de beperking voor Jira, die beperkt is tot alleen-lezen toegang: zonder deze beperking zou een kwaadaardige instructie in de body van een ticket het model kunnen aanzetten tot een schrijfbewerking.

De verborgen kosten van overvloed

Elke toegevoegde tool, MCP of native, neemt ruimte in beslag in het contextvenster om de definitie op te slaan. Een royale configuratie kost u dus beschikbare ruimte voor conversatie, verwerkingstijd en selectienauwkeurigheid.

Drie gewoonten volstaan om dit binnen de perken te houden. Beperk het totale aantal tools en weersta de verleiding om vijf servers met vijftig tools te koppelen als uw use case er slechts tien vereist. Pas allowed_tool_names toe op elke MCP-server om alleen relevante tools over te houden. Voeg ook geen native tool toe “voor het geval dat”: als uw agent geen reden heeft om code uit te voeren, is code_interpreter geen gratis optie; het verbruikt context en biedt een extra kans om de verkeerde tool te kiezen.

Belangrijkste punten

  • MCP-tools en native tools (web search, code execution) bestaan naast elkaar in dezelfde tools-array
  • Grok orkestreert automatisch oproepen tussen MCP- en native tools op basis van de query
  • De combinatie stelt u in staat krachtige agents te creëren die zowel interne bronnen (MCP) als externe bronnen (web search) benutten
  • Beperk het totale aantal tools om context en modelnauwkeurigheid te behouden
  • Gebruik allowed_tool_names voor elke MCP-server om ruis te verminderen