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.
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:
Antes de comenzar, asegúrate de tener:
# 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 .
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
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
}
}
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)
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}")
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
}
}
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())
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())
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}")
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]}...")
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)
| Problema | Solución |
|---|---|
| Error "Clave API no válida" | Verifica que tu clave API de OpenAI sea correcta y tenga suficientes permisos |
| Limitación de tasa | Implementa retroceso exponencial y limitación de solicitudes |
| Errores de tiempo de espera | Aumenta el tiempo de espera en la configuración o verifica la conexión de red |
| Modelo no encontrado | Verifica que el nombre del modelo exista en los modelos disponibles de OpenAI |
| Límite de token excedido | Divide las solicitudes en partes más pequeñas o utiliza streaming |
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.
