FastAPI MCP Server adalah alat revolusioner yang menjembatani kesenjangan antara aplikasi FastAPI Anda dan agen AI menggunakan Model Context Protocol (MCP). Di era di mana integrasi AI menjadi semakin penting, solusi tanpa konfigurasi ini memungkinkan Anda untuk mengekspos endpoint FastAPI yang ada sebagai alat yang dapat ditemukan dan digunakan oleh model dan agen AI dengan sedikit usaha.
Pengantar FastAPI MCP
Model Context Protocol (MCP) adalah standar yang sedang berkembang yang memungkinkan model AI untuk berinteraksi dengan alat dan sumber daya eksternal. FastAPI MCP Server berfungsi sebagai jembatan antara aplikasi FastAPI Anda yang ada dan agen AI yang kompatibel dengan MCP seperti Claude dari Anthropic, Cursor IDE, dan lainnya, tanpa mengharuskan Anda untuk menulis ulang API Anda atau mempelajari kerangka kerja baru yang kompleks.
Apa yang membuat FastAPI MCP benar-benar luar biasa adalah pendekatan tanpa konfigurasinya. Ia secara otomatis mengubah endpoint FastAPI Anda yang ada menjadi alat yang kompatibel dengan MCP, dengan tetap mempertahankan skema endpoint, dokumentasi, dan fungsionalitas Anda. Ini berarti agen AI dapat menemukan dan berinteraksi dengan API Anda dengan pengaturan minimal yang diperlukan dari Anda.
Anda dapat menemukan repositori server FastAPI MCP di: https://github.com/tadata-org/fastapi_mcp
Memulai dengan FastAPI MCP
Instalasi
Sebelum Anda dapat menggunakan FastAPI MCP, Anda perlu menginstalnya. Pengembang merekomendasikan penggunaan uv, penginstal paket Python yang cepat, tetapi Anda juga dapat menggunakan metode pip tradisional:
Menggunakan uv:
uv add fastapi-mcp
Menggunakan pip:
pip install fastapi-mcp
Implementasi Dasar
Mengintegrasikan FastAPI MCP dengan aplikasi FastAPI Anda yang ada sangatlah mudah. Berikut adalah implementasi yang paling dasar:
from fastapi import FastAPI
from fastapi_mcp import FastApiMCP
# Aplikasi FastAPI Anda yang ada
app = FastAPI()
# Buat server MCP
mcp = FastApiMCP(
app,
name="My API MCP",
description="My API description",
base_url="http://localhost:8000" # Penting untuk perutean permintaan
)
# Pasang server MCP ke aplikasi FastAPI Anda
mcp.mount()
Itu saja! Dengan kode sederhana ini, server MCP Anda sekarang tersedia di https://app.base.url/mcp. Ketika klien yang kompatibel dengan MCP terhubung ke endpoint ini, ia akan secara otomatis menemukan semua rute FastAPI Anda sebagai alat yang tersedia.
Memahami Nama Alat MCP dan ID Operasi
Ketika FastAPI MCP mengekspos endpoint Anda sebagai alat, ia menggunakan operation_id dari rute FastAPI Anda sebagai nama alat MCP. FastAPI secara otomatis menghasilkan ID ini ketika tidak disediakan secara eksplisit, tetapi mereka bisa menjadi samar dan kurang ramah pengguna.
Bandingkan dua pendekatan ini:
# operation_id yang dihasilkan secara otomatis (kurang ramah pengguna)
@app.get("/users/{user_id}")
async def read_user(user_id: int):
return {"user_id": user_id}
# operation_id eksplisit (lebih ramah pengguna)
@app.get("/users/{user_id}", operation_id="get_user_info")
async def read_user(user_id: int):
return {"user_id": user_id}
Dalam contoh pertama, alat tersebut mungkin dinamai seperti "read_user_users__user_id__get", sedangkan contoh kedua hanya akan menjadi "get_user_info". Untuk kegunaan yang lebih baik, terutama ketika agen AI berinteraksi dengan alat Anda, disarankan untuk secara eksplisit mendefinisikan ID operasi yang jelas dan deskriptif.
Opsi Konfigurasi Tingkat Lanjut
FastAPI MCP menyediakan beberapa opsi penyesuaian untuk menyesuaikan bagaimana API Anda diekspos ke klien MCP.
Menyesuaikan Deskripsi Skema
Anda dapat mengontrol berapa banyak informasi yang disertakan dalam deskripsi alat:
mcp = FastApiMCP(
app,
name="My API MCP",
base_url="http://localhost:8000",
describe_all_responses=True, # Sertakan semua kemungkinan skema respons
describe_full_response_schema=True # Sertakan detail skema JSON lengkap
)
Memfilter Endpoint
Anda mungkin ingin mengontrol endpoint mana yang diekspos sebagai alat MCP. FastAPI MCP menawarkan beberapa mekanisme pemfilteran:
# Hanya sertakan operasi tertentu berdasarkan ID operasi
mcp = FastApiMCP(
app,
include_operations=["get_user", "create_user"]
)
# Kecualikan operasi tertentu
mcp = FastApiMCP(
app,
exclude_operations=["delete_user"]
)
# Filter berdasarkan tag
mcp = FastApiMCP(
app,
include_tags=["users", "public"]
)
# Kecualikan berdasarkan tag
mcp = FastApiMCP(
app,
exclude_tags=["admin", "internal"]
)
# Gabungkan strategi pemfilteran
mcp = FastApiMCP(
app,
include_operations=["user_login"],
include_tags=["public"]
)
Perhatikan bahwa Anda tidak dapat menggabungkan filter penyertaan dan pengecualian dari jenis yang sama (operasi atau tag), tetapi Anda dapat menggunakan filter operasi bersama dengan filter tag.
Strategi Penyebaran
FastAPI MCP menawarkan fleksibilitas dalam cara Anda menyebarkan server MCP Anda.
Memasang ke Aplikasi Asli
Pendekatan paling sederhana adalah memasang server MCP langsung ke aplikasi FastAPI asli Anda seperti yang ditunjukkan dalam contoh dasar. Ini membuat endpoint di /mcp di aplikasi Anda yang ada.
Menyebarkan sebagai Layanan Terpisah
Anda juga dapat membuat server MCP dari satu aplikasi FastAPI dan memasangnya ke aplikasi yang berbeda, memungkinkan Anda untuk menyebarkan API Anda dan antarmuka MCP-nya secara terpisah:
from fastapi import FastAPI
from fastapi_mcp import FastApiMCP
# Aplikasi API asli Anda
api_app = FastAPI()
# Definisikan endpoint Anda di sini...
# Aplikasi terpisah untuk server MCP
mcp_app = FastAPI()
# Buat server MCP dari aplikasi API
mcp = FastApiMCP(
api_app,
base_url="http://api-host:8001" # URL tempat aplikasi API akan berjalan
)
# Pasang server MCP ke aplikasi terpisah
mcp.mount(mcp_app)
# Sekarang jalankan kedua aplikasi secara terpisah:
# uvicorn main:api_app --host api-host --port 8001
# uvicorn main:mcp_app --host mcp-host --port 8000
Pemisahan ini dapat bermanfaat untuk mengelola sumber daya, keamanan, dan penskalaan.
Memperbarui MCP Setelah Menambahkan Endpoint Baru
Jika Anda menambahkan endpoint ke aplikasi FastAPI Anda setelah membuat server MCP, Anda perlu menyegarkan server untuk menyertakannya:
# Pengaturan awal
app = FastAPI()
mcp = FastApiMCP(app)
mcp.mount()
# Kemudian, tambahkan endpoint baru
@app.get("/new/endpoint/", operation_id="new_endpoint")
async def new_endpoint():
return {"message": "Hello, world!"}
# Segarkan server MCP untuk menyertakan endpoint baru
mcp.setup_server()
Menghubungkan ke Server MCP Anda
Setelah aplikasi FastAPI Anda dengan integrasi MCP berjalan, klien dapat terhubung ke sana dengan berbagai cara.
Menggunakan Server-Sent Events (SSE)
Banyak klien MCP, seperti Cursor IDE, mendukung koneksi SSE:
- Jalankan aplikasi Anda
- Di Cursor → Settings → MCP, gunakan URL endpoint server MCP Anda (misalnya,
http://localhost:8000/mcp) sebagai URL SSE - Cursor akan secara otomatis menemukan semua alat dan sumber daya yang tersedia
Menggunakan MCP Proxy untuk Klien Tanpa Dukungan SSE
Untuk klien yang tidak mendukung SSE secara langsung (seperti Claude Desktop):
- Jalankan aplikasi Anda
- Instal alat MCP proxy:
uv tool install mcp-proxy - Konfigurasikan klien Anda untuk menggunakan mcp-proxy
Untuk Claude Desktop di Windows, buat file konfigurasi (claude_desktop_config.json):
{
"mcpServers": {
"my-api-mcp-proxy": {
"command": "mcp-proxy",
"args": ["http://127.0.0.1:8000/mcp"]
}
}
}
Untuk macOS, Anda perlu menentukan jalur lengkap ke executable mcp-proxy, yang dapat Anda temukan menggunakan which mcp-proxy.
Kasus Penggunaan Dunia Nyata
FastAPI MCP membuka banyak kemungkinan untuk aplikasi bertenaga AI:
- Alat Analisis Data: Ekspos endpoint pemrosesan data yang dapat digunakan agen AI untuk menganalisis data pengguna tanpa memerlukan integrasi khusus untuk setiap model AI.
- Sistem Manajemen Konten: Izinkan alat AI untuk mengambil dan memperbarui konten melalui API CMS Anda yang ada, membuat pembuatan dan pengelolaan konten lebih efisien.
- Mesin Pencari Kustom: Aktifkan asisten AI untuk mencari database khusus atau repositori konten Anda melalui antarmuka API sederhana.
- Operasi E-commerce: Biarkan agen AI memeriksa inventaris, informasi produk, atau melakukan pemesanan melalui endpoint API e-commerce Anda yang ada.
- Pemrosesan Dokumen: Berikan alat AI kemampuan untuk membuat, mengonversi, atau menganalisis dokumen menggunakan kemampuan pemrosesan dokumen backend Anda.
Praktik Terbaik
Untuk mendapatkan hasil maksimal dari FastAPI MCP, pertimbangkan praktik terbaik ini:
- Gunakan ID operasi eksplisit: Definisikan ID operasi yang jelas dan deskriptif untuk semua endpoint Anda untuk membuatnya lebih mudah digunakan oleh agen AI.
- Berikan dokumentasi yang komprehensif: Sertakan deskripsi terperinci untuk setiap endpoint dan parameter untuk membantu model AI memahami cara menggunakan alat Anda secara efektif.
- Gunakan penamaan parameter yang konsisten: Terapkan konvensi penamaan yang konsisten untuk parameter serupa di berbagai endpoint.
- Pertimbangkan implikasi keamanan: Berhati-hatilah tentang endpoint mana yang Anda ekspos melalui MCP dan terapkan otentikasi yang tepat jika diperlukan.
- Pantau penggunaan: Lacak bagaimana agen AI menggunakan alat MCP Anda untuk mengidentifikasi pola, kesalahan, atau area untuk perbaikan.
Kesimpulan
FastAPI MCP Server mewakili langkah maju yang signifikan dalam membuat layanan backend dapat diakses oleh agen AI. Dengan secara otomatis mengonversi endpoint FastAPI Anda yang ada menjadi alat yang kompatibel dengan MCP tanpa konfigurasi, ia menghilangkan kebutuhan akan integrasi khusus atau penyesuaian kompleks pada desain API Anda.
Seiring ekosistem MCP terus berkembang dan lebih banyak model AI mengadopsi standar ini, memiliki API Anda yang diekspos melalui FastAPI MCP akan memposisikan layanan Anda agar mudah diakses oleh berbagai agen dan alat AI. Apakah Anda sedang membangun perkakas internal, layanan pengembang, atau API publik, FastAPI MCP menawarkan jalur langsung untuk membuat layanan Anda dapat diakses oleh AI.
Dengan mengikuti panduan dalam artikel ini, Anda dapat dengan cepat mengintegrasikan FastAPI MCP ke dalam aplikasi FastAPI Anda yang ada dan mulai menjelajahi kemungkinan otomatisasi bertenaga AI dan interaksi dengan layanan Anda.
