Dolphin-MCP adalah implementasi sumber terbuka yang memperluas Protokol Model Konteks (MCP) dari Anthropic untuk bekerja dengan berbagai model bahasa di luar Claude. Panduan teknis ini akan memandu Anda melalui pengaturan dan pemanfaatan Dolphin-MCP khususnya dengan API OpenAI, memungkinkan Anda memanfaatkan model GPT melalui arsitektur MCP.
Dolphin-MCP bertindak sebagai lapisan penerjemahan antara spesifikasi MCP dan berbagai API LLM. Untuk integrasi OpenAI, ini:
Sebelum mulai, pastikan Anda memiliki:
# Kloning repositori Dolphin-MCP
git clone https://github.com/cognitivecomputations/dolphin-mcp.git
cd dolphin-mcp
# Buat lingkungan virtual
python -m venv venv
source venv/bin/activate # Pada Windows: venv\Scripts\activate
# Instal dependensi
pip install -r requirements.txt
# Instal paket dalam mode pengembangan
pip install -e .
Buat file .env di root proyek Anda:
OPENAI_API_KEY=sk-your-openai-api-key-here
MCP_MODEL=gpt-4-0125-preview
MCP_PROVIDER=openai
Buat file config.json:
{
"provider": "openai",
"model_settings": {
"model": "gpt-4-0125-preview",
"temperature": 0.7,
"max_tokens": 2048
},
"api_config": {
"api_key": "sk-your-openai-api-key-here",
"base_url": "https://api.openai.com/v1",
"timeout": 120
}
}
from dolphin_mcp import DolphinMCP
# Inisialisasi klien
mcp_client = DolphinMCP.from_config("./config.json")
# Buat percakapan
conversation = mcp_client.create_conversation()
# Tambahkan pesan sistem
conversation.add_system_message("Anda adalah asisten AI yang membantu yang berspesialisasi dalam pemrograman Python.")
# Kirim pesan pengguna dan dapatkan respons
response = conversation.add_user_message("Bagaimana cara mengimplementasikan pohon pencarian biner di Python?")
# Cetak respons
print(response.content)
from dolphin_mcp import DolphinMCP
from dolphin_mcp.tools import WebSearchTool, CodeExecutionTool
# Inisialisasi klien dengan alat
mcp_client = DolphinMCP.from_config("./config.json")
# Daftarkan alat
mcp_client.register_tool(WebSearchTool(api_key="your-search-api-key"))
mcp_client.register_tool(CodeExecutionTool())
# Buat percakapan dengan alat diaktifkan
conversation = mcp_client.create_conversation()
# Tambahkan instruksi sistem untuk alat
conversation.add_system_message("""
Anda adalah asisten AI dengan akses ke alat berikut:
- web_search: Cari informasi terkini di internet
- code_execution: Eksekusi kode Python dengan aman di sandbox
Gunakan alat ini ketika sesuai untuk memberikan respons yang akurat dan membantu.
""")
# Pertanyaan pengguna yang memerlukan alat
response = conversation.add_user_message(
"Apa cuaca saat ini di New York? Juga, dapatkah Anda menunjukkan cara menghitung faktorial dari suatu angka di Python?"
)
# Respons otomatis akan menyertakan penggunaan alat
print(response.content)
print("\nEksekusi alat:")
for tool_name, tool_result in response.tool_results.items():
print(f"{tool_name}: {tool_result}")
Jika Anda ingin menggunakan endpoint alternatif yang kompatibel dengan OpenAI (seperti Azure OpenAI atau model yang dihosting sendiri), ubah konfigurasi Anda:
{
"provider": "openai",
"model_settings": {
"model": "your-custom-model-deployment",
"temperature": 0.7,
"max_tokens": 2048
},
"api_config": {
"api_key": "your-api-key",
"base_url": "https://your-custom-endpoint.com/v1",
"api_version": "2023-07-01-preview", // Untuk Azure
"api_type": "azure" // Untuk Azure
}
}
Dolphin-MCP memungkinkan Anda untuk membuat alat kustom untuk model OpenAI. Berikut cara mengimplementasikan alat kalkulator kustom:
from dolphin_mcp.tools import BaseTool
import math
class CalculatorTool(BaseTool):
name = "calculator"
description = "Melakukan perhitungan matematis"
async def execute(self, expression: str):
try:
# Buat lingkungan yang aman dengan fungsi matematika terbatas
safe_env = {
"sqrt": math.sqrt,
"sin": math.sin,
"cos": math.cos,
"tan": math.tan,
"pi": math.pi,
"e": math.e
}
# Evaluasi ekspresi dalam lingkungan yang aman
result = eval(expression, {"__builtins__": {}}, safe_env)
return str(result)
except Exception as e:
return f"Kesalahan dalam perhitungan: {str(e)}"
@property
def parameters(self):
return {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "Ekspresi matematis yang akan dievaluasi"
}
},
"required": ["expression"]
}
# Contoh penggunaan
mcp_client = DolphinMCP.from_config("./config.json")
mcp_client.register_tool(CalculatorTool())
Untuk aplikasi yang memerlukan respons waktu nyata:
async def stream_response():
mcp_client = DolphinMCP.from_config("./config.json")
conversation = mcp_client.create_conversation()
# Siapkan percakapan
conversation.add_system_message("Anda adalah asisten AI yang membantu.")
# Streaming respons
async for chunk in conversation.add_user_message_streaming(
"Jelaskan komputasi kuantum dalam istilah sederhana."
):
if chunk.type == "content":
print(chunk.content, end="", flush=True)
elif chunk.type == "tool_start":
print(f"\n[Memulai penggunaan alat: {chunk.tool_name}]")
elif chunk.type == "tool_result":
print(f"\n[Hasil alat dari {chunk.tool_name}]: {chunk.result}")
elif chunk.type == "error":
print(f"\nKesalahan: {chunk.error}")
print("\nRespons selesai.")
# Jalankan fungsi async
import asyncio
asyncio.run(stream_response())
Implementasikan penanganan kesalahan yang kuat untuk mengelola masalah 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("Buat respons kompleks")
except MCPTimeoutError:
print("Permintaan telah habis waktu. Periksa koneksi jaringan Anda atau tingkatkan nilai waktu habis.")
except MCPAPIError as e:
print(f"Kesalahan API: {e.status_code} - {e.message}")
if e.status_code == 429:
print("Batas tarif terlampaui. Implementasikan percepatan eksponensial.")
except MCPConfigError as e:
print(f"Kesalahan Konfigurasi: {e}")
except Exception as e:
print(f"Kesalahan tak terduga: {e}")
Untuk lingkungan produksi, pertimbangkan optimasi berikut:
# Penggunaan sesi ulang untuk pengelolaan koneksi
from dolphin_mcp import DolphinMCP
import aiohttp
async def optimized_mcp_usage():
# Buat sesi bersama untuk pengelolaan koneksi
async with aiohttp.ClientSession() as session:
mcp_client = DolphinMCP.from_config(
"./config.json",
session=session,
request_timeout=60,
connection_pool_size=10
)
# Proses beberapa percakapan secara efisien
tasks = []
for i in range(5):
conversation = mcp_client.create_conversation()
conversation.add_system_message("Anda adalah asisten yang membantu.")
tasks.append(conversation.add_user_message_async(f"Pertanyaan {i}: Apa itu pembelajaran mesin?"))
# Kumpulkan semua respons
responses = await asyncio.gather(*tasks)
for i, response in enumerate(responses):
print(f"Respons {i}: {response.content[:100]}...")
Contoh integrasi 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")
# Ambil atau buat percakapan
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("Anda adalah asisten AI yang membantu.")
# Proses pesan
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)
| Masalah | Solusi |
|---|---|
| Kesalahan "Kunci API tidak valid" | Verifikasi bahwa kunci API OpenAI Anda benar dan memiliki izin yang cukup |
| Pembatasan tarif | Implementasikan percepatan eksponensial dan throttling permintaan |
| Kesalahan waktu habis | Tingkatkan waktu habis dalam konfigurasi atau periksa koneksi jaringan |
| Model tidak ditemukan | Verifikasi nama model ada dalam model yang tersedia di OpenAI |
| Batas token terlampaui | Bagi permintaan menjadi potongan yang lebih kecil atau gunakan streaming |
Dolphin-MCP menyediakan cara fleksibel dan sumber terbuka untuk menggunakan model OpenAI dengan protokol MCP. Implementasi ini membebaskan pengembang dari keterikatan vendor sambil mempertahankan antarmuka yang konsisten di berbagai penyedia LLM. Dengan mengikuti langkah-langkah dalam panduan ini, Anda dapat memanfaatkan kekuatan model GPT melalui arsitektur MCP yang telah distandarisasi.
philschmid.de menunjukkan integrasi serupa dengan LLM lainnya, dan alat seperti mcpadapt dapat membantu memperluas kemampuan Dolphin-MCP lebih jauh.
