Le Model Context Protocol (MCP) devient rapidement l’un des concepts les plus discutés dans le monde de l’IA. Bien qu’encore relativement récent, il a déjà attiré l’attention des développeurs et des grandes entreprises technologiques.
Créé par Anthropic, MCP est un protocole ouvert standard, similaire à d’autres protocoles comme HTTP. Cependant, alors que HTTP est conçu pour connecter les utilisateurs à des ressources via un serveur et un navigateur web (ou un client HTTP), MCP est conçu pour connecter les grands modèles de langage (LLM) à des outils et données externes.
Imaginons que vous ayez un chatbot et que vous souhaitiez qu’il puisse accéder à GitHub. Vous voulez que vos utilisateurs utilisent le chatbot pour créer des issues, les fermer, ajouter des commentaires ou consulter des pull requests existantes. Pour que votre chatbot puisse effectuer toutes ces actions, il devra avoir accès à des outils.
C’est là qu’intervient un serveur MCP.
Le serveur MCP héberge plusieurs outils que le chatbot peut appeler en utilisant son LLM interne pour obtenir ces capacités. Dans le cas de GitHub, nous pouvons utiliser le serveur MCP officiel de GitHub pour effectuer toutes les tâches mentionnées ci-dessus.
Dans cet article, nous allons construire un serveur MCP utilisant l’API Novita. Avec ce serveur MCP, toute application supportant le protocole MCP pourra accéder à tous les LLM disponibles sur Novita, générer des images, créer des vidéos et effectuer de la synthèse vocale.
Comprendre l’architecture MCP
L’architecture MCP [source]
L’architecture MCP est similaire à une configuration client-serveur classique. Elle comporte quatre composants importants :
- Client MCP
- Serveur MCP
- Transports MCP
- Hôte MCP
Client MCP
Le client MCP sert de passerelle de communication entre l’application IA et un serveur MCP. Une fois cette communication établie, l’application peut accéder à tous les outils et ressources que possède le serveur.
Serveur MCP
Le serveur MCP héberge tous les outils et données que le client peut fournir à l’application IA. Il héberge les éléments suivants :
- Outils
- Ressources
- Prompts
Outils
Les outils offrent aux LLM des capacités externes qu’ils n’auraient normalement pas, comme la capacité de donner l’heure, de mettre à jour et de lire une base de données, d’obtenir la météo, etc. Ces outils sont essentiellement des fonctions définies par le programmeur et pouvant être appelées.
Un serveur MCP peut héberger plusieurs outils. Ces outils permettent au LLM de fonctionner comme un agent, grâce aux actions qu’il peut réaliser.
Les outils sont gérés par l’agent et peuvent impliquer une supervision humaine facultative lors de leur utilisation. Ils sont similaires aux requêtes POST dans le protocole HTTP car ils produisent des effets de bord.
Ressources
Les ressources sont des informations en lecture seule qui fournissent des données à l’application IA. Elles sont analogues aux requêtes HTTP GET, car elles ne sont pas destinées à provoquer d’effets de bord. Les ressources sont conçues pour être gérées par l’application, qui décide comment les utilisateurs ou l’agent interagiront avec elles. Parmi les exemples de ressources, on trouve le contenu de fichiers, les réponses d’API et les enregistrements de bases de données.
Prompts
Les serveurs MCP peuvent héberger des modèles de prompts. Ces prompts permettent à l’utilisateur de récupérer des prompts depuis le serveur MCP, qui peuvent ensuite être utilisés dans l’application IA. Les prompts sont gérés par l’utilisateur, qui décide quels prompts fournir à l’agent.
Tous ces éléments constituent le serveur MCP. Dans cet article, nous n’implémenterons que des outils, car ce sont les plus utilisés du serveur MCP.
Transport MCP
Le transport MCP fait référence à la méthode par laquelle le client MCP communique avec le serveur MCP. Cette communication peut avoir lieu localement, lorsque le client et le serveur s’exécutent sur la même machine, ou à distance, lorsqu’ils se trouvent sur des appareils séparés. MCP prend actuellement en charge deux principaux mécanismes de transport :
- STDIO : Dans ce mode, le serveur MCP et le client s’exécutent sur la même machine et communiquent via l’entrée et la sortie standard.
- SSE : Dans ce mode, le serveur MCP s’exécute via HTTP. HTTP POST est utilisé pour envoyer des messages au serveur, tandis que les événements envoyés par le serveur (Server-Sent Events) sont utilisés pour envoyer des messages du serveur au client.
- HTTP streamable : Ce mode utilise également HTTP mais repose sur les requêtes HTTP GET et POST. Il bascule vers SSE uniquement lorsqu’il doit diffuser plusieurs messages du serveur au client.
Entrée/Sortie standard
Transport MCP utilisant STDIO [source]
Légende : Transport MCP utilisant STDIO [source]
Le client et le serveur MCP peuvent communiquer via l’entrée et la sortie standard (STDIO). En utilisant STDIO, le client et le serveur s’exécutent tous deux sur la même machine. Le client écrit toutes les requêtes sur stdin, tandis que le serveur écrit la réponse sur stdout.
HTTP streamable
Transport MCP utilisant HTTP streamable [source]
HTTP streamable permet au client et au serveur MCP de communiquer via HTTP. Il utilise la méthode HTTP POST pour envoyer des requêtes du client et recevoir des réponses du serveur. Si nécessaire, il peut éventuellement basculer vers les événements envoyés par le serveur (Server-Sent Events - SSE) pour diffuser des messages du serveur au client.
HTTP streamable est bien adapté à la communication à distance entre un client et un serveur et constitue le remplacement du transport SSE obsolète de MCP.
Hôte MCP
Ce qui distingue MCP d’une architecture client-serveur classique, c’est le rôle de l’hôte. La spécification MCP le définit comme une architecture client-hôte-serveur. En effet, le client et l’hôte constituent la partie frontale de l’architecture. L’hôte MCP se compose de deux éléments importants :
- Le(s) client(s) MCP
- Un grand modèle de langage
Le rôle du client MCP est de récupérer auprès du serveur les outils, ressources et prompts nécessaires au LLM. Une fois les ressources collectées, elles sont placées dans le contexte du modèle. Un seul hôte MCP peut avoir plusieurs clients, chacun connecté à son propre serveur MCP.
L’hôte MCP peut également être considéré comme l’application sur laquelle l’utilisateur travaille, qui peut avoir d’autres fonctions. Par exemple, Claude Desktop est un hôte MCP qui fonctionne comme un chatbot, Cursor est un hôte MCP qui sert également d’EDI, et Claude Code est un hôte MCP conçu comme un agent de codage IA.
Travailler avec un serveur MCP
Avant de construire notre serveur MCP, voyons comment travailler avec un serveur MCP existant. Nous utiliserons le SDK Python MCP pour interagir avec le novita-mcp-server.
Au moment de la rédaction de cet article, le novita-mcp-server fournit les outils suivants :
- Un outil pour lister tous les clusters Novita
- Un outil pour lister les produits d’instances GPU Novita
- Un outil pour lister toutes les instances GPU en cours d’exécution
- Un outil pour créer de nouvelles instances GPU
Vérifions cela en écrivant un script simple qui se connecte au serveur MCP via STDIO et liste tous les outils disponibles sur le serveur.
Pour commencer, installons le SDK MCP : pip install “mcp[cli]”
Après avoir installé le SDK, nous pouvons créer un fichier appelé client.py. Ensuite, nous allons faire toutes les importations nécessaires :
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
Nous utiliserons ensuite StdioServerParameters pour définir nos paramètres afin de lancer notre serveur MCP via stdio. Le novita-mcp-server est implémenté en Node.js, donc pour l’utiliser, nous devons l’exécuter avec la commande npx. Nous devons également stocker notre clé API Novita dans la variable d’environnement NOVITA_API_KEY.
# Create server parameters for stdio connection
server_params = StdioServerParameters(
command="npx",
args=["-y", "@novitalabs/novita-mcp-server"],
env={"NOVITA_API_KEY": os.environ["NOVITA_API_KEY"]},
)
Ensuite, créons une fonction asynchrone. Dans la fonction, nous passerons les paramètres du serveur à la fonction stdio_client, qui créera un contexte renvoyant des flux de lecture et d’écriture. Ces flux nous permettent de lire et d’écrire respectivement sur stdio.
async def run():
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
# Initialize the connection
await session.initialize()
# List available tools
tools = await session.list_tools()
print("Available tools:", tools)
Ces flux sont ensuite utilisés pour créer une session avec la classe ClientSession. Une fois la session créée, nous pouvons l’initialiser puis lister tous les outils du serveur.
Pour exécuter ce programme, il suffit d’utiliser la bibliothèque asyncio pour appeler la fonction run. Voici le code complet :
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
# Create server parameters for stdio connection
server_params = StdioServerParameters(
command="npx",
args=["-y", "@novitalabs/novita-mcp-server"],
env={"NOVITA_API_KEY": os.environ["NOVITA_API_KEY"]},
)
async def run():
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
# Initialize the connection
await session.initialize()
# List available tools
tools = await session.list_tools()
print("Available tools:", tools)
if __name__ == "__main__":
import asyncio
asyncio.run(run())
En exécutant le script, nous pouvons voir tous les outils du serveur MCP Novita.
Cet exemple montre comment utiliser le client MCP. Nous pourrions ajouter un LLM à cet exemple et le transformer ainsi en hôte, mais ce n’est pas l’objectif de ce tutoriel. L’objectif est de construire un serveur MCP.
Construire un serveur MCP avec FastMCP
Dans le SDK Python MCP, il existe deux façons de construire des serveurs MCP. L’une consiste à utiliser le serveur de bas niveau, l’autre à utiliser FastMCP. FastMCP est une classe du SDK Python MCP qui s’inspire de FastAPI pour faciliter la création de serveurs MCP.
Utilisons FastMCP pour créer notre serveur MCP. Avant de commencer, réfléchissons aux fonctionnalités de notre serveur MCP. Le serveur MCP Novita actuel n’implémente que des outils pour la gestion des GPU. Essayons de construire un serveur autour de l’API Novita qui va au-delà de la gestion des GPU.
Construisons plutôt un serveur MCP qui donne accès aux modèles de la plateforme Novita. Notre serveur MCP n’aura que des outils, pas de ressources ni de prompts. Voici la liste des outils que le serveur possédera :
- list_models : Cet outil listera tous les grands modèles de langage sur la plateforme Novita.
- get_model : Cet outil récupérera et utilisera un modèle de langage spécifique.
- text2image : Cet outil générera des images à partir d’un prompt donné.
- task_result : Cet outil sera utilisé pour obtenir l’état d’une tâche en cours via son ID.
- text_to_speech : Cet outil convertira le texte fourni en parole.
- generate_video : Cet outil générera une vidéo à partir d’un prompt donné.
Maintenant que nous savons quels outils nous allons construire, commençons à créer notre serveur. Tout d’abord, créez un fichier appelé server.py et ajoutez-y le code suivant :
import os
import sys
from mcp.server.fastmcp import FastMCP
import requests
import uvicorn
from starlette.applications import Starlette
from starlette.routing import Mount
base_url = "https://api.novita.ai/v3"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}"
}
mcp = FastMCP("Novita_API")
Avec cela, nous avons importé les modules nécessaires, défini notre URL de base et nos en-têtes pour l’API, et créé une instance de la classe FastMCP. Passons à la création de nos outils.
Lister les modèles
Pour créer un outil dans FastMCP, nous devons décorer une fonction avec la méthode tool de l’instance FastMCP. La fonction list_models effectue un appel à l’endpoint de liste des modèles pour obtenir la liste des modèles. La réponse est ensuite formatée correctement afin de pouvoir être transmise au LLM qui l’a appelée.
@mcp.tool()
def list_models() -> str:
"""
List all available models from the Novita API.
"""
url = base_url + "/openai/models"
response = requests.request("GET", url, headers=headers)
data = response.json()["data"]
text = ""
for i, model in enumerate(data, start=1):
text += f"Model id: {model['id']}\
"
text += f"Model description: {model['description']}\
"
text += f"Model type: {model['model_type']}\
\
"
return text
La docstring de l’outil sert à décrire la fonctionnalité de l’outil afin que le LLM comprenne à quoi il sert.
Obtenir un modèle
Cet outil est utilisé pour accéder aux LLM déployés sur Novita. Il prend l’ID du modèle et le prompt pour le modèle. Il utilise l’endpoint API de complétion de chat de Novita.
@mcp.tool()
def get_model(model_id: str, message):
"""
Provide a model ID and a message to get a response from the Novita API.
"""
url = base_url + "/openai/chat/completions"
payload = {
"model": model_id,
"messages": [
{
"content": message,
"role": "user",
}
],
"max_tokens": 200,
"response_format": {
"type": "text",
},
}
response = requests.request("POST", url, json=payload, headers=headers)
content = response.json()["choices"][0]["message"]["content"]
return content
Text2Image
Cet outil génère des images à partir d’un prompt. Il utilise en interne l’endpoint texte-vers-image de Novita. Cet endpoint est asynchrone, il ne renvoie donc pas l’image immédiatement, mais plutôt un ID de tâche.
@mcp.tool()
def text2Image(prompt):
"""
Generate an image from a text prompt using the Novita API.
"""
url = base_url + "/async/txt2img"
payload = {
"request": {
"model_name": "sd_xl_base_1.0.safetensors",
"prompt": prompt,
"width": 1024,
"height": 1024,
"image_num": 1,
"steps": 20,
"clip_skip": 1,
"sampler_name": "Euler a",
"guidance_scale": 7.5,
},
"extra": {
"response_image_type": "jpeg"
}
}
response = requests.request("POST", url, json=payload, headers=headers)
return response.json()["task_id"]
Résultat de tâche
Cet outil est utilisé pour obtenir l’état d’une tâche en cours sur l’API Novita. Il ne prend que l’ID de la tâche. Par exemple, l’outil Image génère une image de manière asynchrone et renvoie un ID de tâche à l’hôte. L’utilisateur peut ensuite demander à l’hôte de récupérer le résultat de cette tâche à l’aide de l’outil Résultat de tâche.
@mcp.tool()
def task_result(task_id: str):
"""
Get the current status of a running task using it's task id
"""
url = base_url + f'/async/task-result?task_id={task_id}'
response = requests.request("GET", url, headers=headers)
return response.json()
Générer une vidéo
Cet outil génère des vidéos à l’aide de l’endpoint Kling AI V1.6 texte-vers-vidéo de l’API Novita. Tout comme l’outil Image, il génère des vidéos de manière asynchrone et renvoie un ID de tâche.
@mcp.tool()
def generateVideo(prompt: str):
"""
Generate an image using a prompt
"""
url = base_url + "/async/kling-v1.6-t2v"
payload = {
"mode": "Standard",
"prompt": prompt,
"negative_prompt": "low quality",
"guidance_scale": 0.6
}
response = requests.post(url, json=payload, headers=headers)
return response.json()
Texte vers parole
Cet outil génère de la parole à l’aide de l’endpoint Texte-vers-Parole de Novita. C’est également un endpoint asynchrone, il renvoie donc aussi un ID de tâche.
@mcp.tool()
def textToSpeech(text, voice_id) -> str:
"""
Generate speech using text and voice id.
It returns the task id of the generated speech.
The available voice ids are:
- Emily
- James
- Olivia
- Michael
- Sarah
- John
"""
url = base_url + "/async/txt2speech"
payload = {
"request": {
"voice_id": voice_id,
"language": "en-US",
"texts": [text]
}
}
response = requests.post(url, json=payload, headers=headers)
return response.json()["task_id"]
Une fois tous nos outils définis, nous pouvons ensuite mettre en place notre mécanisme de transport. Nous allons utiliser stdio.
if __name__ == "__main__":
# Run using stdio transport
mcp.run(transport="stdio")
Nous pouvons maintenant rassembler tout le code :
import os
import sys
from mcp.server.fastmcp import FastMCP
import requests
import uvicorn
from starlette.applications import Starlette
from starlette.routing import Mount
base_url = "https://api.novita.ai/v3"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}"
}
mcp = FastMCP("Novita_API")
@mcp.tool()
def list_models() -> str:
"""
List all available models from the Novita API.
"""
url = base_url + "/openai/models"
response = requests.request("GET", url, headers=headers)
data = response.json()["data"]
text = ""
for i, model in enumerate(data, start=1):
text += f"Model id: {model['id']}\
"
text += f"Model description: {model['description']}\
"
text += f"Model type: {model['model_type']}\
\
"
return text
@mcp.tool()
def get_model(model_id: str, message) -> str:
"""
Provide a model ID and a message to get a response from the Novita API.
"""
url = base_url + "/openai/chat/completions"
payload = {
"model": model_id,
"messages": [
{
"content": message,
"role": "user",
}
],
"max_tokens": 200,
"response_format": {
"type": "text",
},
}
response = requests.request("POST", url, json=payload, headers=headers)
content = response.json()["choices"][0]["message"]["content"]
return content
@mcp.tool()
def text2Image(prompt: str) -> str:
"""
Generate an image from a text prompt using the Novita API.
"""
url = base_url + "/async/txt2img"
payload = {
"request": {
"model_name": "sd_xl_base_1.0.safetensors",
"prompt": prompt,
"width": 1024,
"height": 1024,
"image_num": 1,
"steps": 20,
"clip_skip": 1,
"sampler_name": "Euler a",
"guidance_scale": 7.5,
},
"extra": {
"response_image_type": "jpeg"
}
}
response = requests.request("POST", url, json=payload, headers=headers)
return response.json()["task_id"]
@mcp.tool()
def task_result(task_id: str) -> str:
"""
Get the current status of a running task using it's task id
"""
url = base_url + f'/async/task-result?task_id={task_id}'
response = requests.request("GET", url, headers=headers)
return response.json()
@mcp.tool()
def generateVideo(prompt: str) -> str:
"""
Generate an image using a prompt
"""
url = base_url + "/async/kling-v1.6-t2v"
payload = {
"mode": "Standard",
"prompt": prompt,
"negative_prompt": "low quality",
"guidance_scale": 0.6
}
response = requests.post(url, json=payload, headers=headers)
return response.json()["task_id"]
@mcp.tool()
def textToSpeech(text, voice_id) -> str:
"""
Generate speech using text and voice id.
It returns the task id of the generated speech.
The available voice ids are:
- Emily
- James
- Olivia
- Michael
- Sarah
- John
"""
url = base_url + "/async/txt2speech"
payload = {
"request": {
"voice_id": voice_id,
"language": "en-US",
"texts": [text]
}
}
response = requests.post(url, json=payload, headers=headers)
return response.json()["task_id"]
if __name__ == "__main__":
# Run using stdio transport
mcp.run(transport="stdio")
Nous pouvons tester notre serveur MCP sur n’importe quel hôte MCP, comme Claude Desktop, Cursor ou VS Code, en utilisant la configuration suivante :
{
"command": "python",
"args": [
"path/to/server.py"
],
"env": {
"NOVITA_API_KEY": "sk_...."
}
}
Nous pouvons également utiliser le script client que nous avons développé précédemment pour tester notre serveur.
Utiliser le serveur MCP de bas niveau
Le serveur que nous avons construit dans la section précédente utilise la classe FastMCP, qui fournit une interface de haut niveau pour construire des serveurs MCP. Vous pouvez également construire des serveurs MCP en utilisant le serveur de bas niveau, ce qui vous donne un contrôle granulaire sur le protocole MCP. Voyons comment modifier le serveur de la section précédente pour utiliser le serveur de bas niveau.
Gestion des outils
L’une des choses que FastMCP fait est de gérer les outils que vous définissez. Lorsque vous décorez une fonction avec le décorateur tool de la classe FastMCP, FastMCP ajoute cet outil à une liste. Lorsque l’agent demande cet outil, FastMCP le récupère, l’appelle, puis renvoie le résultat à l’agent.
Avec le serveur de bas niveau, nous pouvons gérer ce processus nous-mêmes en utilisant le décorateur call_tool.
@app.call_tool()
async def manage_tool(name: str, arguments: dict ) -> list[types.TextContent]:
if name == "list_models":
return await list_models_tool()
if name == "get_model":
return await get_model_tool(arguments)
else:
raise ValueError(f"Unknown tool: {name}")
Le code ci-dessus montre une fonction décorée avec la méthode call_tool. Lorsque l’agent appelle un outil, il transmet le nom de l’outil et tous les arguments que l’outil attend. En utilisant le nom de la fonction, nous pouvons ensuite déterminer quel outil l’agent souhaite appeler et l’exécuter.
Nous devons également gérer le listage des outils avec le serveur de bas niveau, contrairement à FastMCP qui le fait automatiquement lorsqu’une fonction est décorée avec la méthode tool.
@app.list_tools()
async def list_tools() -> list[types.Tool]:
return [
types.Tool(
name="list_models",
description="List all available models from the Novita API.",
inputSchema={"type": "object", "properties": {}},
),
types.Tool(
name="get_model",
description="Provide a model ID and a message to get a response from the Novita API.",
inputSchema={
"type": "object",
"required": ["model_id", "message"],
"properties": {
"model_id": {
"type": "string",
"description": "The ID of the model to use.",
},
"message": {
"type": "string",
"description": "The input message to send.",
},
},
},
),
]
Voici le code complet du serveur de bas niveau. Il contient deux outils et peut communiquer avec le client via l’entrée et la sortie standard.
import os
import asyncio
import requests
from mcp.server.lowlevel import Server
from mcp.server.stdio import stdio_server
import mcp.types as types
base_url = "https://api.novita.ai/v3"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}"
}
app = Server("Novita_API")
async def list_models_tool():
"""
Lists all available models from the Novita API.
"""
url = base_url + "/openai/models"
response = requests.get(url, headers=headers)
data = response.json()["data"]
text = ""
for i, model in enumerate(data, start=1):
text += f"Model id: {model['id']}\
"
text += f"Model description: {model['description']}\
"
text += f"Model type: {model['model_type']}\
\
"
return [types.TextContent(type="text", text=text)]
async def get_model_tool(arguments: dict):
"""
Given a model ID and a user message, fetch a response from the Novita API.
"""
model_id = arguments.get("model_id")
message = arguments.get("message")
if not model_id or not message:
raise ValueError("Both 'model_id' and 'message' are required.")
url = base_url + "/openai/chat/completions"
payload = {
"model": model_id,
"messages": [
{
"content": message,
"role": "user",
}
],
"max_tokens": 200,
"response_format": {
"type": "text",
},
}
response = requests.post(url, json=payload, headers=headers)
content = response.json()["choices"][0]["message"]["content"]
return [types.TextContent(type="text", text=content)]
@app.call_tool()
async def manage_tool(name: str, arguments: dict ) -> list[types.TextContent]:
if name == "list_models":
return await list_models_tool()
if name == "get_model":
return await get_model_tool(arguments)
else:
raise ValueError(f"Unknown tool: {name}")
@app.list_tools()
async def list_tools() -> list[types.Tool]:
return [
types.Tool(
name="list_models",
description="List all available models from the Novita API.",
inputSchema={"type": "object", "properties": {}},
),
types.Tool(
name="get_model",
description="Provide a model ID and a message to get a response from the Novita API.",
inputSchema={
"type": "object",
"required": ["model_id", "message"],
"properties": {
"model_id": {
"type": "string",
"description": "The ID of the model to use.",
},
"message": {
"type": "string",
"description": "The input message to send.",
},
},
},
),
]
async def main():
async with stdio_server() as streams:
await app.run(streams[0], streams[1], app.create_initialization_options())
if __name__ == "__main__":
asyncio.run(main())
Le serveur de bas niveau ne vous offre pas seulement un contrôle fin sur la gestion des outils ; il fournit également un contrôle de bas niveau sur les ressources, les prompts et d’autres parties du protocole MCP, comme la gestion du cycle de vie.
Conclusion
Dans ce tutoriel, nous avons construit un serveur MCP qui utilise l’API Novita pour améliorer les capacités de tout hôte MCP. Vous avez appris les bases nécessaires à la création d’un serveur MCP, notamment comment définir et exposer des outils.
Avec ces fondations, vous pouvez commencer à explorer des sujets plus avancés tels que l’authentification, le déploiement de serveurs MCP distants et le travail direct avec l’implémentation Python de bas niveau.
Nous avons également exploré l’API Novita elle-même et vu ses capacités, allant d’un ensemble diversifié de modèles de langage à des outils de génération pour la vidéo, l’audio et les images. Visitez le bac à sable LLM de Novita pour essayer d’autres API que nous n’avons pas eu le temps de couvrir, comme les endpoints d’édition d’images et de visages.
Novita AI est une plateforme cloud IA qui offre aux développeurs un moyen simple de déployer des modèles IA via notre API simple, tout en fournissant un cloud GPU abordable et fiable pour construire et passer à l’échelle.
