Cómo usar MCP con la API de OpenAI usando Dolphin-MCP

Introducción

Dolphin-MCP es una implementación de código abierto que amplía el Protocolo de Contexto del Modelo (MCP) de Anthropic para trabajar con varios modelos de lenguaje más allá de Claude. Esta guía técnica te guiará a través de la configuración y utilización de Dolphin-MCP específicamente con la API de OpenAI, permitiéndote aprovechar los modelos GPT a través de la arquitectura MCP.

Visión Técnica

Dolphin-MCP actúa como una capa de traducción entre la especificación MCP y varias API de LLM. Para la integración de OpenAI, lo hace:

• Convierte mensajes del protocolo MCP a formatos de la API de OpenAI
• Maneja las diferencias de mapeo de tokens entre modelos
• Gestiona el estado y el historial de la conversación
• Proporciona capacidades de ejecución de herramientas de manera agnóstica al modelo

Prerequisitos

Antes de comenzar, asegúrate de tener:

• Python 3.8+
• pip (gestor de paquetes)
• Clave de API de OpenAI
• Git instalado
• Comprensión básica de LLMs y conceptos de API

Pasos de Instalación

# Clonar el repositorio Dolphin-MCP
git clone https://github.com/cognitivecomputations/dolphin-mcp.git
cd dolphin-mcp

# Crear un entorno virtual
python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

# Instalar dependencias
pip install -r requirements.txt

# Instalar el paquete en modo de desarrollo
pip install -e .

Configuración

1. Configuración de Variables de Entorno

Crea un archivo .env en la raíz de tu proyecto:

OPENAI_API_KEY=sk-tu-clave-api-openai-aqui
MCP_MODEL=gpt-4-0125-preview
MCP_PROVIDER=openai

2. Creando un Archivo de Configuración

Crea un archivo config.json:

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

Ejemplos de Uso Básico

Ejemplo 1: Conversación Simple

from dolphin_mcp import DolphinMCP

# Inicializar el cliente
mcp_client = DolphinMCP.from_config("./config.json")

# Crear una conversación
conversation = mcp_client.create_conversation()

# Añadir un mensaje del sistema
conversation.add_system_message("Eres un asistente de IA útil especializado en programación en Python.")

# Enviar un mensaje de usuario y obtener una respuesta
response = conversation.add_user_message("¿Cómo implemento un árbol de búsqueda binaria en Python?")

# Imprimir la respuesta
print(response.content)

Ejemplo 2: Uso de Herramientas con OpenAI

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

# Inicializar el cliente con herramientas
mcp_client = DolphinMCP.from_config("./config.json")

# Registrar herramientas
mcp_client.register_tool(WebSearchTool(api_key="tu-clave-api-de-busqueda"))
mcp_client.register_tool(CodeExecutionTool())

# Crear conversación con herramientas habilitadas
conversation = mcp_client.create_conversation()

# Añadir instrucciones del sistema para las herramientas
conversation.add_system_message("""
Eres un asistente de IA con acceso a las siguientes herramientas:
- web_search: Busca en internet información actual
- code_execution: Ejecuta código Python de forma segura en un entorno aislado

Usa estas herramientas cuando sea apropiado para proporcionar respuestas precisas y útiles.
""")

# Consulta del usuario que requiere herramientas
response = conversation.add_user_message(
    "¿Cuál es el clima actual en Nueva York? Además, ¿puedes mostrarme cómo calcular el factorial de un número en Python?"
)

# La respuesta incluirá el uso de herramientas automáticamente
print(response.content)
print("\nEjecuciones de herramientas:")
for tool_name, tool_result in response.tool_results.items():
    print(f"{tool_name}: {tool_result}")

Configuración Avanzada

Uso de Puntos Finales Compatibles con OpenAI

Si deseas usar puntos finales alternativos compatibles con OpenAI (como Azure OpenAI o modelos auto-alojados), modifica tu configuración:

{
  "provider": "openai",
  "model_settings": {
    "model": "tu-despliegue-de-modelo-personalizado",
    "temperature": 0.7,
    "max_tokens": 2048
  },
  "api_config": {
    "api_key": "tu-clave-api",
    "base_url": "https://tu-punto-final-personalizado.com/v1",
    "api_version": "2023-07-01-preview",  // Para Azure
    "api_type": "azure"  // Para Azure
  }
}

Implementación de Herramientas Personalizadas

Dolphin-MCP te permite crear herramientas personalizadas para modelos de OpenAI. Aquí tienes cómo implementar una herramienta calculadora personalizada:

from dolphin_mcp.tools import BaseTool
import math

class CalculatorTool(BaseTool):
    name = "calculadora"
    description = "Realiza cálculos matemáticos"
    
    async def execute(self, expression: str):
        try:
            # Crear un entorno seguro con funciones matemáticas limitadas
            safe_env = {
                "sqrt": math.sqrt,
                "sin": math.sin,
                "cos": math.cos,
                "tan": math.tan,
                "pi": math.pi,
                "e": math.e
            }
            
            # Evaluar la expresión en el entorno seguro
            result = eval(expression, {"__builtins__": {}}, safe_env)
            return str(result)
        except Exception as e:
            return f"Error en el cálculo: {str(e)}"
    
    @property
    def parameters(self):
        return {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "La expresión matemática a evaluar"
                }
            },
            "required": ["expression"]
        }

# Ejemplo de uso
mcp_client = DolphinMCP.from_config("./config.json")
mcp_client.register_tool(CalculatorTool())

Manejo de Respuestas en Streaming

Para aplicaciones que requieren respuestas en tiempo real:

async def stream_response():
    mcp_client = DolphinMCP.from_config("./config.json")
    conversation = mcp_client.create_conversation()
    
    # Configurar la conversación
    conversation.add_system_message("Eres un asistente de IA útil.")
    
    # Transmitir la respuesta
    async for chunk in conversation.add_user_message_streaming(
        "Explica la computación cuántica en términos simples."
    ):
        if chunk.type == "content":
            print(chunk.content, end="", flush=True)
        elif chunk.type == "tool_start":
            print(f"\n[Comenzando a usar la herramienta: {chunk.tool_name}]")
        elif chunk.type == "tool_result":
            print(f"\n[Resultado de la herramienta de {chunk.tool_name}]: {chunk.result}")
        elif chunk.type == "error":
            print(f"\nError: {chunk.error}")
    
    print("\nRespuesta completa.")

# Ejecutar la función asíncrona
import asyncio
asyncio.run(stream_response())

Manejo de Errores

Implementa un manejo de errores robusto para gestionar problemas de 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("Generar una respuesta compleja")
    
except MCPTimeoutError:
    print("La solicitud excedió el tiempo de espera. Verifica tu conexión de red o aumenta el valor de tiempo de espera.")
    
except MCPAPIError as e:
    print(f"Error de API: {e.status_code} - {e.message}")
    if e.status_code == 429:
        print("Límite de tasa excedido. Implementa retroceso exponencial.")
    
except MCPConfigError as e:
    print(f"Error de Configuración: {e}")
    
except Exception as e:
    print(f"Error inesperado: {e}")

Optimización del Rendimiento

Para entornos de producción, considera estas optimizaciones:

# Reutilización de sesión para agrupación de conexiones
from dolphin_mcp import DolphinMCP
import aiohttp

async def optimized_mcp_usage():
    # Crear una sesión compartida para agrupación de conexiones
    async with aiohttp.ClientSession() as session:
        mcp_client = DolphinMCP.from_config(
            "./config.json",
            session=session,
            request_timeout=60,
            connection_pool_size=10
        )
        
        # Procesar múltiples conversaciones de manera eficiente
        tasks = []
        for i in range(5):
            conversation = mcp_client.create_conversation()
            conversation.add_system_message("Eres un asistente útil.")
            tasks.append(conversation.add_user_message_async(f"Pregunta {i}: ¿Qué es el aprendizaje automático?"))
        
        # Reunir todas las respuestas
        responses = await asyncio.gather(*tasks)
        
        for i, response in enumerate(responses):
            print(f"Respuesta {i}: {response.content[:100]}...")

Integración con Aplicaciones Web

Ejemplo de integración en 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")
    
    # Recuperar o crear conversación
    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("Eres un asistente de IA útil.")
    
    # Procesar el mensaje
    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)

Solución de Problemas Comunes

Conclusión

Dolphin-MCP proporciona una manera flexible y de código abierto de utilizar modelos de OpenAI con el protocolo MCP. Esta implementación libera a los desarrolladores de la dependencia de proveedores mientras mantiene una interfaz consistente entre diferentes proveedores de LLM. Siguiendo los pasos en esta guía, puedes aprovechar el poder de los modelos GPT a través de la arquitectura MCP estandarizada.

philschmid.de muestra integraciones similares con otros LLMs, y herramientas como mcpadapt pueden ayudar a ampliar aún más las capacidades de Dolphin-MCP.