Création d'un serveur de protocole de contexte modèle à l'aide de Jina.ai et FastMCP en Python

Dans cet article, nous discuterons du protocole de contexte de modèle, pourquoi il pourrait être important et nous expliquerons la création d'un serveur MCP pour nous aider à parler à Jina.ai et à pouvoir ajouter des fonctionnalités de recherche sur le Web et de vérification des faits dans Claude. Bureau utilisant Python et FastMCP.

Le protocole de contexte modèle

Anthropic annoncé autour de Thanksgiving l'année dernière. Bien qu’il ait suscité une certaine attention, la reconnaissance qu’il a reçue peut être insuffisante, étant donné qu’il pourrait constituer un tremplin crucial dans le développement de la prochaine couche de la pile logicielle d’IA.

Quoi

Le Model Context Protocol (MCP) est un protocole de communication standardisé conçu spécifiquement pour les grands modèles de langage (LLM).

Considérez-le comme le « HTTP de l'IA » : tout comme HTTP a standardisé la manière dont les navigateurs Web communiquent avec les serveurs Web, MCP standardise la manière dont les applications LLM communiquent avec les outils et les sources de données.

Pourquoi avons-nous besoin de MCP ?

Le paysage actuel du développement LLM est confronté à plusieurs obstacles :

1. Complexité de l'intégration des outils : Chaque service LLM (comme OpenAI, Anthropic, etc.) a sa manière d'implémenter les appels d'outils et les appels de fonctions, ce qui rend complexe la création d'outils portables.

2. Gestion du contexte : les LLM ont besoin d'accéder à diverses sources de données et outils, mais gérer cet accès de manière sécurisée et efficace a été un défi.

3. Standardisation : Sans protocole standard, les développeurs doivent reconstruire les couches d'intégration pour chaque plate-forme LLM qu'ils souhaitent prendre en charge.

MCP résout ces défis en fournissant :

• Une manière standardisée d'exposer des outils et des données aux LLM
• Une architecture client-serveur sécurisée
• Une interface cohérente quel que soit le LLM sous-jacent

Comment fonctionne le MCP ?

MCP suit une architecture client-serveur avec trois composants principaux :

1. Serveur MCP : Un service qui expose :

   • Outils (fonctions que les LLM peuvent appeler)
   • Ressources (sources de données)
   • Invites (instructions modèles)
   • Contexte (informations dynamiques)

2. Client MCP : L'application se connecte aux serveurs MCP et gère la communication entre le LLM et les serveurs. Le support client en est à ses débuts, avec seulement une poignée d'outils qui implémentent jusqu'à présent n'importe quelle partie de la spécification du protocole et certaines fonctionnalités qu'aucun client ne prend encore en charge.

Et, bien sûr, le LLM...

Le flux de travail est simple :

1. Un serveur MCP enregistre ses capacités (outils, ressources, etc.)
2. Un client se connecte au serveur
3. Le LLM peut ensuite utiliser ces capacités via une interface standardisée

Protocole de transport

• Mécanismes de transport multiples
  • SSE (événements envoyés par le serveur)
    • Communique via HTTP de manière bidirectionnelle, le processus serveur est isolé du client
  • Stdio (Entrée/Sortie standard)
    • Communique via des canaux d'entrée/sortie standard, le processus serveur est essentiellement un processus enfant du client

Sécurité

La situation sécuritaire est plus nuancée. Alors que les serveurs utilisant le transport stdio sont généralement colocalisés avec le client, les clés API ne sont donc pas nécessairement exposées à Internet. Ils semblent être transmis de manière assez décontractée, OMI.

Ces clés devaient être chargées dans le client au démarrage du serveur afin qu'elles puissent être transmises au processus enfant, et elles apparaissaient même dans les journaux de l'application de bureau, ce qui était... préoccupant.

L'utilisation généralisée des clés API est un problème plus large affectant les services, les plates-formes et les outils Gen AI. Des entreprises comme Okta et Auth0 travaillent sur une solution pour gérer et autoriser les Gen AI sans recourir aux clés.

SDK

Anthropic prend officiellement en charge les SDK de bas niveau pour TypeScript, Python et Kotlin. Certains des wrappers passe-partout récemment créés couvrent déjà une partie du passe-partout et disposent d'autres fonctionnalités intéressantes, telles qu'une CLI pour le débogage, l'inspection et l'installation de serveurs sur le client afin de faciliter le développement de serveurs MCP.

Premiers pas avec FastMCP

jlowin / fastmcp

Le moyen rapide et pythonique de créer des serveurs Model Context Protocol ?

FastMCP ?

La manière rapide et pythonique de créer des serveurs MCP.

Les serveurs Model Context Protocol (MCP) constituent un nouveau moyen standardisé de fournir du contexte et des outils à vos LLM, et FastMCP rend la création de serveurs MCP simple et intuitive. Créez des outils, exposez des ressources et définissez des invites avec un code Pythonique propre :

# demo.py

from fastmcp import FastMCP


mcp = FastMCP("Demo ?")


@<span>mcp.tool()</span>
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

C'est ça ! Donnez à Claude l'accès au serveur en exécutant :

fastmcp install demo.py

FastMCP gère tous les détails complexes du protocole et la gestion des serveurs, afin que vous puissiez vous concentrer sur la création d'excellents outils. Il est conçu pour être de haut niveau et Pythonique - dans la plupart des cas, décorer une fonction est tout ce dont vous avez besoin.

Principales fonctionnalités :

• Rapide : une interface de haut niveau signifie moins de code et un développement plus rapide
• Simple…

Voir sur GitHub

FastMCP est l'un de ces frameworks. Nous allons maintenant explorer comment créer un outil presque pratique pour lire des sites Web, répondre aux requêtes de recherche sur le Web et vérifier les informations. Nous utiliserons Jina.ai.

Il s'agit d'un service très astucieux qui fournit une « plate-forme Search Foundation » qui combine « Embeddings, Rerankers et Small Language Models » pour aider les entreprises à créer des expériences de recherche Gen AI et multimodales.

Conditions préalables

• uv

Vous aurez besoin d’installer UV. C'est la méthode recommandée pour créer et gérer des projets Python. Il fait partie d'une chaîne d'outils Python relativement récente mais passionnante appelée astral.sh. Je vous recommande de le vérifier.

Il vise à être un guichet unique pour la gestion des projets, des dépendances, des environnements virtuels, des versions, du linting et de l'exécution de scripts et de modules Python. C'est écrit en Rust. Faites de cette information ce que vous voulez ?.

• Application de bureau Claude

Vous devrez également installer l'application de bureau Claude. Pour nos besoins, l'application de bureau Claude servira de client MCP et constitue un client cible clé pour Anthropic.

ASRagab / lecteur mcp-jinaai

Serveur MCP (Model Context Protocol) pour l'API Jina.ai Reader

Serveur MCP pour l'API Jina.ai Reader

Procédure complète ici :

https://dev.to/asragab/building-a-model-context-protocol-server-using-jinaai-and-fastmcp-in-python-1od8

Voir sur GitHub

Configuration du projet

En utilisant uv vous pouvez initialiser un projet avec :

# demo.py

from fastmcp import FastMCP


mcp = FastMCP("Demo ?")


@<span>mcp.tool()</span>
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

Cela créera un dossier appelé mcp-jinaai-reader et une version .python ainsi qu'un pyproject.toml.

fastmcp install demo.py

Cela créera un environnement virtuel correspondant à la version python que nous avons choisie.

Après avoir créé l'environnement, il fournira des instructions sur la façon de l'activer pour la session.

uv init mcp-jinaai-reader --python 3.11

Ajoutez un répertoire src et installez la dépendance dont nous avons besoin

cd mcp-jinaai-reader
uv venv 

Créez un fichier .env à la racine du projet et ajoutez votre JINAAI_API_KEY au fichier. Vous pouvez en obtenir un gratuitement en vous inscrivant sur Jina. En général, toutes les clés API ou autres variables d'environnement que votre serveur doit exécuter iront dans ce fichier.

source .venv/bin/activate

Dans le répertoire src, créez un fichier server.py... et nous devrions pouvoir accéder au code.

Code du serveur

uv add fastmcp

En commençant par les importations : httpx, sera la bibliothèque que nous utiliserons ici pour faire des requêtes http ; nous avons besoin de la méthode urlparse pour nous aider à déterminer si une chaîne est éventuellement une URL valide.

JINAAI_API_KEY=jina_*************

Cela initialise le serveur ; le premier argument est le nom de l'outil. Je ne suis pas sûr à 100% de la raison pour laquelle uvicorn doit être explicitement ajouté en tant que dépendance ici puisqu'il s'agit d'une dépendance transitive de FastMCP, mais cela semble être nécessaire.

Cela est probablement dû à la façon dont le fastmcp cli (plus d'informations à ce sujet sous peu) installe le serveur. Si vous avez d'autres dépendances, vous devez les ajouter ici afin que le client sache que vous devez les installer avant d'exécuter le client ; nous verrons comment cela fonctionne dans un instant.

from fastmcp import FastMCP
import httpx
from urllib.parse import urlparse
import os

Vous pouvez probablement comprendre le modèle ici, mais Jina utilise différents sous-domaines pour acheminer des requêtes particulières. Le point de terminaison de recherche attend une requête, le point de terminaison de lecteur attend une URL et le point de terminaison de mise à la terre peut fournir au llm une réponse ou une réponse spécifique.

L'ancrage est un sujet beaucoup plus vaste et est utilisé avec d'autres techniques, telles que le RAG et le réglage fin, pour aider les LLM à réduire les hallucinations et à améliorer la prise de décision.

Notre premier outil

# Initialize the MCP server
mcp = FastMCP("search", dependencies=["uvicorn"])

L'annotation @mcp.tool fait le gros du travail. Des annotations similaires pour les ressources et les invites existent dans la bibliothèque. L'annotation extrait les détails de la signature de la fonction et du type de retour pour créer un schéma d'entrée et de sortie permettant au llm d'appeler l'outil. Il configure l'outil pour que le client comprenne les capacités du serveur. Il enregistre également les appels de fonction en tant que gestionnaires pour l'outil configuré.

Ensuite, vous remarquerez que la fonction est asynchrone. Aucune configuration d'exécution n'est nécessaire, et aucun élément asyncio.run non plus. Si, pour une raison quelconque, vous devez exécuter le serveur en tant que service autonome, vous devez gérer une partie de cette opération vous-même. Il existe un exemple dans le dépôt FastMCP expliquant comment procéder.

Le corps de la fonction est raisonnablement inintéressant ; il vérifie s'il reçoit une URL, définit les en-têtes appropriés, appelle le point de terminaison Jina et renvoie le texte.

# demo.py

from fastmcp import FastMCP


mcp = FastMCP("Demo ?")


@<span>mcp.tool()</span>
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

Deuxième outil

fastmcp install demo.py

Et c'est tout...

Test et débogage

uv init mcp-jinaai-reader --python 3.11

L'exécution de la commande ci-dessus démarrera l'inspecteur mcp, c'est un outil fourni par le SDK afin de tester et de déboguer les réponses du serveur. L'option --with-editable permet d'apporter des modifications au serveur, sans avoir à relancer l'inspecteur (fortement, FORTEMENT recommandé)

Vous devriez voir :

cd mcp-jinaai-reader
uv venv 

Par défaut, l'inspecteur s'exécute sur le port 5173 et le serveur (le code que vous venez d'écrire) s'exécutera sur le port 3000, vous pouvez modifier cela en définissant SERVER_PORT et CLIENT_PORT avant l'invocation.

source .venv/bin/activate

L'inspecteur

Si tout se passe bien, vous devriez voir quelque chose comme ceci, à gauche vous pouvez ajouter les variables d'environnement dont vous aurez besoin, ici la JINAAI_API_KEY est la seule.

Si vous cliquez sur Outils dans la barre de menu supérieure, puis sur Liste des outils, vous devriez voir les outils que nous avons créés, notez que la docstring sert de description de l'outil.

Cliquer sur un outil particulier fera apparaître les zones de texte vous permettant de saisir les paramètres nécessaires pour appeler l'outil.

Installation du serveur

Une fois que vous êtes satisfait que tout fonctionne comme prévu, vous êtes maintenant prêt à installer le serveur sur le client Claude Desktop App.

uv add fastmcp

Je vais le faire, je suis sûr qu'à l'avenir, cela prendra en charge d'autres clients, mais pour l'instant, c'est tout ce que vous avez à faire. Le -f .env transmettra les variables d'environnement au client de l'application.

Ce que cela fait sous le capot, c'est mettre à jour le fichier claude_desktop_config.json et fournir la commande et les arguments nécessaires pour exécuter le serveur. Par défaut, cela utilise uv qui doit être disponible sur votre PATH.

Si vous ouvrez maintenant l'application de bureau Claude, accédez à la barre de menus et cliquez sur Claude > Paramètres puis cliquez sur Développeur, vous devriez voir le nom de votre outil que vous avez défini lors de l'initialisation du serveur.

Cliquer dessus devrait faire apparaître sa configuration. Non seulement vous saurez comment il sera exécuté, mais dans les options avancées, vous verrez les variables d'environnement qui ont été définies.

Vous pouvez également modifier cette configuration directement, mais je ne la recommanderais pas nécessairement ici.

L'exécuter

Si tout se passe bien lorsque vous accédez à l'application de bureau, vous ne devriez voir aucune erreur (si c'est le cas, accéder aux paramètres devrait vous donner un bouton pour consulter les journaux et enquêter à partir de là).

De plus, vous devriez voir un symbole de marteau avec le nombre d'outils individuels dont vous disposez (remarque : le vôtre devrait probablement être de deux, sauf si vous avez installé d'autres serveurs MCP)

Plutôt que d'invoquer l'outil directement, vous discutez avec l'application comme vous le feriez normalement, et lorsqu'elle rencontre une situation où elle en déduit que l'outil est utile, elle vous demandera si vous souhaitez l'utiliser. Aucun code ou configuration supplémentaire n’est nécessaire ici.

Je pense que cela dépend à la fois du nom et de la description de l'outil pour décider s'il est approprié, cela vaut donc la peine d'élaborer une description claire et simple de ce que fait l'outil.

Vous recevrez une invite comme celle-ci :

Et vous pouvez simplement « discuter » avec lui, certes, l'outil tel qu'écrit rencontre parfois des problèmes. Parfois, il décide qu'il ne peut pas accéder à Internet, parfois il ne parvient pas à récupérer les résultats, mais parfois vous obtenez ceci :

Cela avait une sorte de flux naturel, où il lisait la page, fournissait un résumé, et vous lui demandiez d'accéder à un article spécifique et de le lire.

Notes finales

J'espère que cela vous a donné un aperçu des serveurs MCP. Il y a beaucoup à lire et à regarder, mais un autre site que je recommanderai est glama.ai. Ils conservent une liste assez complète des serveurs MCP disponibles à télécharger et à essayer, y compris d'autres outils de recherche sur le Web plus fiables que notre exemple de jouet. Vérifiez-le et merci de nous suivre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!