Version imprimable multipages. Cliquer ici pour imprimer.
Les documents d’explication discutent et clarifient les concepts pour élargir la compréhension du lecteur sur les sujets. Ils fournissent du contexte et éclairent les idées.
Cette section fournit un contexte plus approfondi sur le fonctionnement de gomcptest, son architecture et les concepts qui le sous-tendent.
Ce document explique l’architecture de gomcptest, les décisions de conception qui la sous-tendent, et comment les différents composants interagissent pour créer un hôte personnalisé pour le Protocole de Contexte de Modèle (MCP).
Le projet gomcptest implémente un hôte personnalisé qui fournit une implémentation du Protocole de Contexte de Modèle (MCP). Il est conçu pour permettre les tests et l’expérimentation avec des systèmes d’agents sans nécessiter d’intégration directe avec des plateformes LLM commerciales.
Le système est construit avec ces principes clés à l’esprit :
L’hôte est le composant central, situé dans /host/openaiserver. Il présente une interface API compatible OpenAI et se connecte à Vertex AI de Google pour l’inférence de modèle. Cette couche de compatibilité facilite l’intégration avec des outils et bibliothèques existants conçus pour OpenAI.
L’hôte a plusieurs responsabilités clés :
Contrairement aux implémentations commerciales, cet hôte est conçu pour le développement et les tests locaux, privilégiant la flexibilité et l’observabilité aux fonctionnalités prêtes pour la production comme l’authentification ou la limitation de débit.
Les outils sont des exécutables autonomes qui implémentent le Protocole de Contexte de Modèle. Chaque outil est conçu pour exécuter une fonction spécifique, comme l’exécution de commandes shell ou la manipulation de fichiers.
Les outils suivent un modèle cohérent :
Cette approche permet aux outils d’être :
L’interface en ligne de commande fournit une interface utilisateur similaire à des outils comme “Claude Code” ou “OpenAI ChatGPT”. Elle se connecte au serveur compatible OpenAI et offre un moyen d’interagir avec le LLM et les outils via une interface conversationnelle.
L’API OpenAI est devenue un standard de facto dans l’espace des LLM. En implémentant cette interface, gomcptest peut fonctionner avec une grande variété d’outils, de bibliothèques et d’interfaces existants avec une adaptation minimale.
Vertex AI donne accès aux modèles Gemini de Google, qui possèdent de solides capacités d’appel de fonctions. L’implémentation pourrait être étendue pour prendre en charge d’autres fournisseurs de modèles si nécessaire.
En implémentant les outils comme des exécutables autonomes plutôt que des fonctions de bibliothèque, nous obtenons plusieurs avantages :
Le Protocole de Contexte de Modèle fournit une manière standardisée pour les LLM d’interagir avec des outils externes. En adoptant ce protocole, gomcptest assure la compatibilité avec les outils développés pour d’autres hôtes compatibles MCP.
L’implémentation actuelle présente plusieurs limitations :
Les améliorations futures pourraient inclure :
L’architecture de gomcptest représente une approche flexible et extensible pour construire des hôtes MCP personnalisés. Elle privilégie la simplicité, la modularité et l’expérience développeur, ce qui en fait une excellente plateforme pour l’expérimentation avec des systèmes d’agents.
En comprenant cette architecture, les développeurs peuvent utiliser efficacement le système, l’étendre avec de nouveaux outils, et potentiellement l’adapter à leurs besoins spécifiques.
This document explores the Model Context Protocol (MCP), how it works, the design decisions behind it, and how it compares to alternative approaches for LLM tool integration.
The Model Context Protocol (MCP) is a standardized communication protocol that enables Large Language Models (LLMs) to interact with external tools and capabilities. It defines a structured way for models to request information or take actions in the real world, and for tools to provide responses back to the model.
MCP is designed to solve the problem of extending LLMs beyond their training data by giving them access to:
At its core, MCP is a protocol based on JSON-RPC that enables bidirectional communication between LLMs and tools. The basic workflow is:
The protocol specifies:
In gomcptest, MCP is implemented using a set of independent executables that communicate over standard I/O. This approach has several advantages:
Each tool in gomcptest follows a consistent pattern:
The core MCP protocol in gomcptest follows this format:
Tools register themselves with a schema that defines their capabilities:
{
"name": "ToolName",
"description": "Description of what the tool does",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "Description of parameter 1"
},
"param2": {
"type": "number",
"description": "Description of parameter 2"
}
},
"required": ["param1"]
}
}
When a model wants to use a tool, it generates a function call like:
{
"name": "ToolName",
"params": {
"param1": "value1",
"param2": 42
}
}
The tool executes the requested action and returns:
{
"result": "Output of the tool's execution"
}
Or, in case of an error:
{
"error": {
"message": "Error message",
"code": "ERROR_CODE"
}
}
Several key design decisions shape the MCP implementation in gomcptest:
By using stdin/stdout for communication, tools can be written in any language that can read from stdin and write to stdout. This makes it easy to integrate existing utilities and libraries.
Using JSON Schema for tool definitions provides a clear contract between the model and the tools. It enables:
Tools are designed to be stateless, with each invocation being independent. This simplifies the protocol and makes tools easier to reason about and test.
The protocol doesn’t handle authentication directly; instead, it relies on the host to manage permissions and authentication. This separation of concerns keeps the protocol simple.
MCP is similar to OpenAI’s function calling feature but with these key differences:
Compared to LangChain:
Other agent protocols often focus on higher-level concepts like goals and planning, while MCP focuses specifically on the mechanics of tool invocation.
The MCP protocol in gomcptest could evolve in several ways:
The Model Context Protocol as implemented in gomcptest represents a pragmatic approach to extending LLM capabilities through external tools. Its simplicity, extensibility, and focus on interoperability make it a solid foundation for building and experimenting with agentic systems.
By understanding the protocol, developers can create new tools that seamlessly integrate with the system, unlocking new capabilities for LLM applications.