Comment utiliser MCP avec l'API d'OpenAI en utilisant Dolphin-MCP

Introduction

Dolphin-MCP est une implémentation open-source qui étend le Protocole de Contexte de Modèle (MCP) d'Anthropic pour fonctionner avec divers modèles de langage au-delà de Claude. Ce guide technique vous guidera dans la configuration et l'utilisation de Dolphin-MCP spécifiquement avec l'API d'OpenAI, vous permettant de tirer parti des modèles GPT via l'architecture MCP.

Vue d'ensemble technique

Dolphin-MCP agit comme une couche de traduction entre la spécification MCP et diverses API LLM. Pour l'intégration avec OpenAI, il :

• Convertit les messages de protocole MCP aux formats d'API d'OpenAI
• Gère les différences de mappage de jetons entre les modèles
• Gère l'état et l'historique de la conversation
• Fournit des capacités d'exécution d'outils de manière agnostique au modèle

Pré-requis

Avant de commencer, assurez-vous d'avoir :

• Python 3.8+
• pip (gestionnaire de paquets)
• Clé API OpenAI
• Git installé
• Compréhension de base des LLM et des concepts API

Étapes d'installation

# Cloner le dépôt Dolphin-MCP
git clone https://github.com/cognitivecomputations/dolphin-mcp.git
cd dolphin-mcp

# Créer un environnement virtuel
python -m venv venv
source venv/bin/activate  # Sous Windows : venv\Scripts\activate

# Installer les dépendances
pip install -r requirements.txt

# Installer le package en mode développement
pip install -e .

Configuration

1. Configuration des variables d'environnement

Créez un fichier .env à la racine de votre projet :

OPENAI_API_KEY=sk-votre-clé-api-openai-ici
MCP_MODEL=gpt-4-0125-preview
MCP_PROVIDER=openai

2. Création d'un fichier de configuration

Créez un fichier config.json :

{
  "provider": "openai",
  "model_settings": {
    "model": "gpt-4-0125-preview",
    "temperature": 0.7,
    "max_tokens": 2048
  },
  "api_config": {
    "api_key": "sk-votre-clé-api-openai-ici",
    "base_url": "https://api.openai.com/v1",
    "timeout": 120
  }
}

Exemples d'utilisation de base

Exemple 1 : Conversation simple

from dolphin_mcp import DolphinMCP

# Initialiser le client
mcp_client = DolphinMCP.from_config("./config.json")

# Créer une conversation
conversation = mcp_client.create_conversation()

# Ajouter un message système
conversation.add_system_message("Vous êtes un assistant IA utile spécialisé dans la programmation Python.")

# Envoyer un message utilisateur et obtenir une réponse
response = conversation.add_user_message("Comment implémenter un arbre de recherche binaire en Python ?")

# Afficher la réponse
print(response.content)

Exemple 2 : Utilisation d'outils avec OpenAI

from dolphin_mcp import DolphinMCP
from dolphin_mcp.tools import WebSearchTool, CodeExecutionTool

# Initialiser le client avec des outils
mcp_client = DolphinMCP.from_config("./config.json")

# Enregistrer des outils
mcp_client.register_tool(WebSearchTool(api_key="votre-clé-api-de-recherche"))
mcp_client.register_tool(CodeExecutionTool())

# Créer une conversation avec les outils activés
conversation = mcp_client.create_conversation()

# Ajouter des instructions système pour les outils
conversation.add_system_message("""
Vous êtes un assistant IA ayant accès aux outils suivants :
- web_search : Recherchez sur Internet des informations actuelles
- code_execution : Exécutez du code Python en toute sécurité dans un environnement isolé

Utilisez ces outils lorsque cela est approprié pour fournir des réponses précises et utiles.
""")

# Requête utilisateur nécessitant des outils
response = conversation.add_user_message(
    "Quel temps fait-il actuellement à New York ? De plus, pouvez-vous me montrer comment calculer le facteuriel d'un nombre en Python ?"
)

# La réponse inclura l'utilisation des outils automatiquement
print(response.content)
print("\nExécutions des outils :")
for tool_name, tool_result in response.tool_results.items():
    print(f"{tool_name} : {tool_result}")

Configuration avancée

Utilisation des points de terminaison compatibles avec OpenAI

Si vous souhaitez utiliser des points de terminaison alternatifs compatibles avec OpenAI (comme Azure OpenAI ou des modèles auto-hébergés), modifiez votre configuration :

{
  "provider": "openai",
  "model_settings": {
    "model": "votre-déploiement-de-modèle-personnalisé",
    "temperature": 0.7,
    "max_tokens": 2048
  },
  "api_config": {
    "api_key": "votre-clé-api",
    "base_url": "https://votre-point-de-terminaison-personnalisé.com/v1",
    "api_version": "2023-07-01-preview",  // Pour Azure
    "api_type": "azure"  // Pour Azure
  }
}

Implémentation d'outils personnalisés

Dolphin-MCP vous permet de créer des outils personnalisés pour les modèles OpenAI. Voici comment implémenter un outil calculateur personnalisé :

from dolphin_mcp.tools import BaseTool
import math

class CalculatorTool(BaseTool):
    name = "calculateur"
    description = "Effectue des calculs mathématiques"
    
    async def execute(self, expression: str):
        try:
            # Créer un environnement sûr avec des fonctions mathématiques limitées
            safe_env = {
                "sqrt": math.sqrt,
                "sin": math.sin,
                "cos": math.cos,
                "tan": math.tan,
                "pi": math.pi,
                "e": math.e
            }
            
            # Évaluer l'expression dans l'environnement sûr
            result = eval(expression, {"__builtins__": {}}, safe_env)
            return str(result)
        except Exception as e:
            return f"Erreur dans le calcul : {str(e)}"
    
    @property
    def parameters(self):
        return {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "L'expression mathématique à évaluer"
                }
            },
            "required": ["expression"]
        }

# Exemple d'utilisation
mcp_client = DolphinMCP.from_config("./config.json")
mcp_client.register_tool(CalculatorTool())

Gestion des réponses en streaming

Pour les applications nécessitant des réponses en temps réel :

async def stream_response():
    mcp_client = DolphinMCP.from_config("./config.json")
    conversation = mcp_client.create_conversation()
    
    # Configurer la conversation
    conversation.add_system_message("Vous êtes un assistant IA utile.")
    
    # Streamer la réponse
    async for chunk in conversation.add_user_message_streaming(
        "Expliquez l'informatique quantique en termes simples."
    ):
        if chunk.type == "content":
            print(chunk.content, end="", flush=True)
        elif chunk.type == "tool_start":
            print(f"\n[Démarrage de l'utilisation de l'outil : {chunk.tool_name}]")
        elif chunk.type == "tool_result":
            print(f"\n[Résultat de l'outil venant de {chunk.tool_name}] : {chunk.result}")
        elif chunk.type == "error":
            print(f"\nErreur : {chunk.error}")
    
    print("\nRéponse complète.")

# Exécuter la fonction async
import asyncio
asyncio.run(stream_response())

Gestion des erreurs

Implémentez une gestion robuste des erreurs pour gérer les problèmes d'API :

from dolphin_mcp.exceptions import MCPAPIError, MCPConfigError, MCPTimeoutError

try:
    mcp_client = DolphinMCP.from_config("./config.json")
    conversation = mcp_client.create_conversation()
    response = conversation.add_user_message("Générez une réponse complexe")
    
except MCPTimeoutError:
    print("La requête a expiré. Vérifiez votre connexion réseau ou augmentez la valeur du délai d'expiration.")
    
except MCPAPIError as e:
    print(f"Erreur API : {e.status_code} - {e.message}")
    if e.status_code == 429:
        print("Limite de taux dépassée. Implémentez une stratégie de rétrogradation exponentielle.")
    
except MCPConfigError as e:
    print(f"Erreur de configuration : {e}")
    
except Exception as e:
    print(f"Erreur inattendue : {e}")

Optimisation des performances

Pour les environnements de production, envisagez ces optimisations :

# Réutilisation de session pour le regroupement de connexions
from dolphin_mcp import DolphinMCP
import aiohttp

async def optimized_mcp_usage():
    # Créer une session partagée pour le regroupement de connexions
    async with aiohttp.ClientSession() as session:
        mcp_client = DolphinMCP.from_config(
            "./config.json",
            session=session,
            request_timeout=60,
            connection_pool_size=10
        )
        
        # Traiter plusieurs conversations efficacement
        tasks = []
        for i in range(5):
            conversation = mcp_client.create_conversation()
            conversation.add_system_message("Vous êtes un assistant utile.")
            tasks.append(conversation.add_user_message_async(f"Question {i} : Qu'est-ce que l'apprentissage automatique ?"))
        
        # Rassembler toutes les réponses
        responses = await asyncio.gather(*tasks)
        
        for i, response in enumerate(responses):
            print(f"Réponse {i} : {response.content[:100]}...")

Intégration avec des applications web

Exemple d'intégration Flask :

from flask import Flask, request, jsonify
from dolphin_mcp import DolphinMCP

app = Flask(__name__)
mcp_client = DolphinMCP.from_config("./config.json")

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    conversation_id = data.get("conversation_id")
    message = data.get("message")
    
    # Récupérer ou créer une conversation
    if conversation_id and conversation_id in active_conversations:
        conversation = active_conversations[conversation_id]
    else:
        conversation = mcp_client.create_conversation()
        conversation_id = conversation.id
        active_conversations[conversation_id] = conversation
        conversation.add_system_message("Vous êtes un assistant IA utile.")
    
    # Traiter le message
    response = conversation.add_user_message(message)
    
    return jsonify({
        "conversation_id": conversation_id,
        "response": response.content,
        "tool_results": response.tool_results
    })

if __name__ == "__main__":
    active_conversations = {}
    app.run(debug=True)

Résolution des problèmes courants

Conclusion

Dolphin-MCP offre un moyen flexible et open-source d'utiliser les modèles OpenAI avec le protocole MCP. Cette implémentation libère les développeurs du verrouillage fournisseur tout en maintenant une interface cohérente à travers différents fournisseurs de LLM. En suivant les étapes de ce guide, vous pouvez tirer parti de la puissance des modèles GPT à travers l'architecture MCP standardisée.

philschmid.de montre des intégrations similaires avec d'autres LLM, et des outils comme mcpadapt peuvent aider à étendre encore plus les capacités de Dolphin-MCP.