Cómo construir su primer servidor MCP con Novita AI

El Protocolo de Contexto de Modelo (MCP) se está convirtiendo rápidamente en uno de los conceptos más comentados en el mundo de la IA. A pesar de ser relativamente nuevo, ya ha captado la atención tanto de desarrolladores como de importantes empresas tecnológicas. 

Creado por Anthropic, MCP es un protocolo estándar abierto, similar a otros protocolos como HTTP. Sin embargo, mientras que HTTP está diseñado para conectar a los usuarios con recursos a través de un servidor y un navegador web (o cliente HTTP), MCP está diseñado para conectar grandes modelos de lenguaje (LLMs) a herramientas y datos externos.

Supongamos que tienes un chatbot y quieres que pueda acceder a GitHub. Quieres que tus usuarios lo usen para crear y cerrar incidencias, añadir comentarios o ver solicitudes de incorporación de cambios. Para que tu chatbot pueda realizar todas estas acciones, necesitará acceso a herramientas.

Aquí es donde entra en juego un servidor MCP. 

El servidor MCP aloja varias herramientas a las que el chatbot puede llamar usando su servidor interno. LLM Para acceder a estas funciones. En el caso de GitHub, podemos usar el servidor oficial de GitHub MCP para realizar todas las tareas mencionadas. 

En este artículo, construiremos un Servidor MCP que utiliza el AP NovitaI. Con este servidor MCP, cualquier aplicación que soporte el protocolo MCP podrá acceder a todos los LLMEstá disponible en Novita, genera imágenes, crea videos y realiza síntesis de voz.

Comprensión de la arquitectura MCP

La arquitectura MCP es similar a una configuración cliente-servidor típica. Consta de cuatro componentes importantes:

• Cliente MCP
• Servidor MCP
• Transportes MCP
• Anfitrión de MCP

Cliente MCP

El cliente MCP actúa como puerta de enlace de comunicación entre la aplicación de IA y un servidor MCP. Una vez establecida la comunicación, la aplicación puede acceder a todas las herramientas y recursos del servidor.

Servidor MCP

El servidor MCP aloja todas las herramientas y datos que el cliente puede proporcionar a la aplicación de IA. Contiene lo siguiente:

• Accesorios
• Recursos 
• Mensajes del sistema

Accesorios

Las herramientas proporcionan capacidades externas a LLMFunciones que normalmente no tendrían, como la capacidad de decir la hora, actualizar y leer una base de datos, obtener el pronóstico del tiempo y más. Estas herramientas son, en esencia, funciones definidas por el programador que se pueden llamar.

Un servidor MCP puede alojar varias herramientas. Estas herramientas permiten... LLM funcionar como agente, debido a las acciones que puede realizar.

Las herramientas son administradas por el agente y pueden requerir supervisión humana opcional durante su uso. Son similares a las solicitudes POST en el protocolo HTTP porque realizan efectos secundarios.

Recursos

Los recursos son fragmentos de información de solo lectura que proporcionan datos a la aplicación de IA. Son similares a las solicitudes HTTP GET, ya que no están diseñados para causar efectos secundarios. Los recursos están diseñados para ser administrados por la aplicación, que decide cómo los usuarios o el agente interactuarán con ellos. Algunos ejemplos de recursos incluyen el contenido de archivos, las respuestas de la API y los registros de bases de datos.

Mensajes del sistema

Los servidores MCP pueden alojar plantillas de avisos. Estos avisos permiten al usuario obtenerlos del servidor MCP, que luego pueden usarse en la aplicación de IA. El usuario gestiona los avisos y decide cuáles enviar al agente.

Todos estos componentes conforman el servidor MCP. En este artículo, solo implementaremos herramientas, ya que son la parte más utilizada del servidor MCP.

Transporte MCP

El transporte MCP se refiere al método mediante el cual el cliente MCP se comunica con el servidor MCP. Esta comunicación puede ocurrir localmente, cuando el cliente y el servidor se ejecutan en la misma máquina, o remotamente, cuando se encuentran en dispositivos separados. MCP actualmente admite dos mecanismos de transporte principales:

• ESTDIO:En este modo, el servidor y el cliente MCP se ejecutan en la misma máquina y se comunican a través de entrada y salida estándar.
• SSEEn este modo, el servidor MCP se ejecuta mediante HTTP. HTTP POST se utiliza para enviar mensajes al servidor, mientras que los eventos enviados por el servidor se utilizan para enviar mensajes del servidor al cliente.
• HTTP transmisibleEste modo también usa HTTP, pero depende de solicitudes HTTP GET y POST. Recurre a SSE solo cuando necesita transmitir varios mensajes del servidor al cliente.

Entrada/Salida estándar

Título: Transporte MCP mediante STDIO [fuente]

El cliente y el servidor MCP pueden comunicarse mediante la entrada y salida estándar (STDIO). Al usar STDIO, tanto el cliente como el servidor se ejecutan en la misma máquina. El cliente escribe todas las solicitudes en la entrada estándar (stdin), mientras que el servidor escribe la respuesta en la salida estándar (stdout).

HTTP transmisible

HTTP transmisible permite que el cliente y el servidor MCP se comuniquen mediante HTTP. Utiliza el método HTTP POST para enviar solicitudes del cliente y recibir respuestas del servidor. Si es necesario, puede optar por usar Eventos Enviados por el Servidor (SSE) para transmitir mensajes del servidor al cliente.

El protocolo HTTP transmitible es adecuado para la comunicación remota entre un cliente y un servidor y sirve como reemplazo del obsoleto transporte MCP SSE.

ANFITRIÓN MCP

La diferencia entre MCP y la arquitectura cliente-servidor típica reside en la función del host. La especificación de MCP la define como una arquitectura cliente-host-servidor. Esto se debe a que el cliente y el host conforman la interfaz de la arquitectura. El host de MCP consta de dos componentes importantes:

• El(los) cliente(s) de MCP
• Un modelo de lenguaje grande

El trabajo del cliente MCP es obtener herramientas, recursos y avisos que el LLM Requiere del servidor. Una vez recopilados los recursos, se ubican en el contexto del modelo. Un solo host MCP puede tener varios clientes, cada uno conectado a su propio servidor MCP.

El host MCP también puede considerarse la aplicación en la que trabaja el usuario, que puede realizar otras funciones. Por ejemplo, Claude Desktop es un host MCP que funciona como chatbot, Cursor es un host MCP que también funciona como IDE, y Claude Code es un host MCP diseñado como agente de codificación de IA.

Trabajar con un servidor MCP

Antes de comenzar a construir nuestro servidor MCP, veamos cómo podemos trabajar con un servidor MCP existente. Usaremos... SDK de Python MCP para interactuar con el servidor novita-mcp.

Al momento de escribir este artículo, novita-mcp-server proporciona las siguientes herramientas:

• Una herramienta para listar todos los clústeres de Novita
• Una herramienta para listar el Novita GPU productos de instancia
• Una herramienta para listar todos los que se están ejecutando GPU instancias
• Una herramienta para crear nuevos GPU instancias
  

Confirmemos esto escribiendo un script simple que se conecte al servidor MCP a través de STDIO y enumere todas las herramientas disponibles en el servidor.

Para comenzar, instalemos el SDK de MCP: pip install “mcp[cli]”

Tras instalar el SDK, podemos crear un archivo llamado client.py. A continuación, realizaremos todas las importaciones necesarias:

desde mcp importar ClientSession, StdioServerParameters desde mcp.client.stdio importar stdio_client importar os

Luego, usaremos StdioServerParameters para configurar los parámetros e iniciar nuestro servidor MCP mediante stdio. El servidor novita-mcp-server está implementado en Node.js, por lo que para usarlo, necesitamos ejecutarlo con el comando npx. También debemos almacenar nuestra clave API de Novita en la variable de entorno NOVITA_API_KEY.

# Crear parámetros de servidor para la conexión stdio server_params = StdioServerParameters( command="npx", args=["-y", "@novitalabs/novita-mcp-server"], env={"NOVITA_API_KEY": os.environ["NOVITA_API_KEY"]}, )

A continuación, crearemos una función asíncrona. Dentro de la función, pasaremos los parámetros del servidor a la función stdio_client, que creará un contexto que devuelve secuencias de lectura y escritura. Estas secuencias nos permiten leer y escribir en stdio, respectivamente.

async def run(): async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session: # Inicializar la conexión await session.initialize() # Listar las herramientas disponibles tools = await session.list_tools() print("Herramientas disponibles:", tools)

Estos flujos se utilizan para crear una sesión con la clase ClientSession. Una vez creada la sesión, podemos inicializarla y listar todas las herramientas en el servidor.

Para ejecutar este programa, solo necesitamos usar la biblioteca asyncio para llamar a la función de ejecución. Aquí está el código completo:

from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client import os # Crear parámetros de servidor para la conexión stdio 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: # Inicializar la conexión await session.initialize() # Listar las herramientas disponibles tools = await session.list_tools() print("Herramientas disponibles:", tools) if __name__ == "__main__": import asyncio asyncio.run(run())

Al ejecutar el script, podremos ver todas las herramientas en el servidor Novita MCP.

Este ejemplo demuestra cómo usar el cliente MCP. Podríamos agregar un LLM A este ejemplo y transformarlo efectivamente en un host, pero ese no es el objetivo de este tutorial. El objetivo es construir un servidor MCP.

Construyendo un servidor MCP con FastMCP

En el SDK de Python para MCP, hay dos maneras de crear servidores MCP. Un método consiste en usar el servidor de bajo nivel y el otro, usar FastMCP. FastMCP es una clase del SDK de Python para MCP que se inspira en FastAPI para facilitar la creación de servidores MCP.

Usemos FastMCP para crear nuestro servidor MCP. Antes de comenzar, veamos las funcionalidades de nuestro servidor MCP. El servidor MCP actual de Novita solo implementa herramientas que gestionan... GPU gestión. Intentemos construir un servidor en torno a la API de Novita que vaya más allá GPU .

En su lugar, construyamos un servidor MCP que proporcione acceso a los modelos en la plataforma Novita. Nuestro servidor MCP solo tendrá herramientas, sin recursos ni indicaciones. A continuación, se muestra una lista de las herramientas que tendrá el servidor:

• lista_modelos:Esta herramienta enumerará todos los modelos de idiomas grandes en la plataforma Novita.
• obtener_modelo:Esta herramienta recuperará y utilizará un modelo de lenguaje grande específico.
• texto2imagen:Esta herramienta generará imágenes a partir de un mensaje determinado.
• resultado de la tarea:Esta herramienta se utilizará para obtener el estado de una tarea en ejecución a través de su ID.
• texto a voz:Esta herramienta convertirá el texto proporcionado en voz.
• generar_video:Esta herramienta generará un vídeo a partir de una indicación determinada.

Ahora que conocemos las herramientas que vamos a construir, comencemos a crear nuestro servidor. Primero, crea un archivo llamado server.py y agrégale el siguiente código:

importar os importar sys desde mcp.server.fastmcp importar FastMCP importar solicitudes importar uvicorn desde starlette.applications importar Starlette desde starlette.routing importar Mount base_url = "https://api.novita.ai/v3" headers = { "Tipo de contenido": "application/json", "Autorización": f"Portador {os.environ['NOVITA_API_KEY']}" } mcp = FastMCP("Novita_API")

Con esto, hemos importado los módulos necesarios, definido la URL base y los encabezados de la API, y creado una instancia de la clase FastMCP. Pasemos a crear nuestras herramientas.

Modelos de lista

Para crear una herramienta en FastMCP, necesitamos decorar una función con el método tool de la instancia de FastMCP. La función list_models realiza una llamada a punto final de los modelos de lista para obtener la lista de modelos. La respuesta se formatea correctamente para que pueda enviarse a LLM que lo llamó.

@mcp.tool() def list_models() -> str: """ Lista todos los modelos disponibles en la API de Novita. """ 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"Id. del modelo: {model['id']}\n" text += f"Descripción del modelo: {model['description']}\n" text += f"Tipo de modelo: {model['model_type']}\n\n" return text

La cadena de documentación en la herramienta sirve como una forma de describir la funcionalidad de la herramienta para que LLM Puede comprender para qué se utiliza la herramienta.

Obtener modelos

Esta herramienta se utiliza para acceder a los implementados LLMs en Novita. Toma el ID del modelo y la solicitud del modelo. Utiliza el Punto final de la API de finalización de chat de Novita.

@mcp.tool() def get_model(model_id: str, message): """ Proporcione un ID de modelo y un mensaje para obtener una respuesta de la API de Novita. """ 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

Texto a imagen

Esta herramienta genera imágenes a partir de un mensaje. Utiliza Novita. punto final de texto a imagen Internamente. Este punto final es asíncrono, por lo que no devuelve la imagen inmediatamente; en su lugar, devuelve un ID de tarea.

@mcp.tool() def text2Image(prompt): """ Genera una imagen a partir de un mensaje de texto usando la API de Novita. """ 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"]

resultado de la tarea

Esta herramienta se utiliza para obtener el estado de una tarea en curso en la API de Novita. Solo toma el ID de la tarea. Por ejemplo, la herramienta Imagen genera una imagen de forma asíncrona y devuelve un ID de tarea al host. El usuario puede solicitar al host que recupere el resultado de esa tarea mediante la herramienta Resultado de la tarea.

@mcp.tool() def task_result(task_id: str): """ Obtener el estado actual de una tarea en ejecución usando su id de tarea """ url = base_url + f'/async/task-result?task_id={task_id}' response = requests.request("GET", url, headers=headers) return response.json()

Generar vídeo

Esta herramienta genera vídeos utilizando las API de Novita Punto final de texto a vídeo de Kling AI V1.6Al igual que la herramienta Imagen, genera videos de forma asincrónica y devuelve un ID de tarea.

@mcp.tool() def generateVideo(prompt: str): """ Generar una imagen usando un mensaje """ url = base_url + "/async/kling-v1.6-t2v" payload = { "mode": "Standard", "prompt": mensaje, "negative_prompt": "low quality", "guidance_scale": 0.6 } response = requests.post(url, json=payload, headers=headers) return response.json()

Texto a voz

Esta herramienta genera voz utilizando la API de Novita Punto final de texto a vozTambién es un punto final asincrónico, por lo que también devuelve un ID de tarea.

@mcp.tool() def textToSpeech(text, voice_id) -> str: """ Genera voz usando el texto y el ID de voz. Devuelve el ID de tarea de la voz generada. Los ID de voz disponibles son: - 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"]

Con todas nuestras herramientas definidas, podemos configurar nuestro mecanismo de transporte. Usaremos stdio.

si __name__ == "__main__": # Ejecutar usando el transporte stdio mcp.run(transport="stdio")

Ahora podemos juntar todo el código:

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: """ Enumera todos los modelos disponibles de la API de Novita.
   """ 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']}\n" text += f"Model description: {model['description']}\n" text += f"Model type: {model['model_type']}\n\n" return text @mcp.tool() def get_model(model_id: str, message) -> str: """ Proporcione un ID de modelo y un mensaje para obtener una respuesta de la API de Novita.
   """ 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: """ Genere una imagen a partir de un mensaje de texto usando la API de Novita.
   """ 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: """ Obtener el estado actual de una tarea en ejecución usando su id de tarea """ 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: """ Generar una imagen usando un mensaje """ url = base_url + "/async/kling-v1.6-t2v" payload = { "mode": "Standard", "prompt": mensaje, "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: """ Generar voz usando texto e id de voz.
   Devuelve el identificador de la tarea del discurso generado.
  
   Los identificadores de voz disponibles son: - 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__": # Ejecutar usando el transporte stdio mcp.run(transport="stdio")

Podemos probar nuestro servidor MCP en cualquier host MCP, como Claude Desktop, Cursor o VS Code, utilizando la siguiente configuración:

{ "comando": "python", "argumentos": [ "ruta/al/servidor.py" ], "env": { "NOVITA_API_KEY": "sk_...." } }

También podemos utilizar el script de cliente que desarrollamos anteriormente para probar nuestro servidor.

Uso del servidor de bajo nivel MCP

El servidor que construimos en la sección anterior utiliza la clase FastMCP, que proporciona una interfaz de alto nivel para crear servidores MCP. También puedes crear servidores MCP usando el servidor de bajo nivel, lo que te brinda control granular sobre el protocolo MCP. Veamos cómo podemos modificar el servidor de la sección anterior para usar el servidor de bajo nivel.

Gestión de herramientas

Una de las funciones de FastMCP es administrar las herramientas que define. Al decorar una función con el decorador de herramientas de la clase FastMCP, FastMCP agrega esa herramienta a una lista. Cuando el agente la solicita, FastMCP la recupera, la invoca y le envía el resultado.

Con el servidor de bajo nivel, podemos gestionar este proceso nosotros mismos utilizando el decorador call_tool.

@app.call_tool() async def manage_tool(nombre: str, argumentos: dict) -> lista[tipos.TextContent]: si nombre == "list_models": devolver esperar list_models_tool() si nombre == "get_model": devolver esperar obtener_model_tool(argumentos) de lo contrario: generar ValueError(f"Herramienta desconocida: {nombre}")

El código anterior muestra una función decorada con el método call_tool. Cuando el agente llama a una herramienta, pasa su nombre y los argumentos que espera. Usando el nombre de la función, podemos determinar qué herramienta desea llamar el agente y ejecutarla.

También podemos administrar el listado de herramientas que utilizan el servidor de bajo nivel, a diferencia de FastMCP, que lo hace automáticamente cuando una función ha sido decorada con el método de herramienta.

@app.list_tools() async def list_tools() -> list[types.Tool]: return [ types.Tool( name="list_models", description="Enumera todos los modelos disponibles de la API de Novita.", inputSchema={"type": "object", "properties": {}}, ), types.Tool( name="get_model", description="Proporciona un ID de modelo y un mensaje para obtener una respuesta de la API de Novita.", inputSchema={ "type": "object", "required": ["model_id", "message"], "properties": { "model_id": { "type": "string", "description": "El ID del modelo a usar.", }, "message": { "type": "string", "description": "El mensaje de entrada a enviar.", }, }, }, ), ]

Aquí está el código completo del servidor de bajo nivel. Contiene dos herramientas y puede comunicarse con el cliente mediante entrada y salida estándar.

importar os importar asyncio importar solicitudes desde mcp.server.lowlevel importar Server desde mcp.server.stdio importar stdio_server importar mcp.types como tipos 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(): """ Enumera todos los modelos disponibles de la API de Novita. """ 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"Id. del modelo: {model['id']}\n" text += f"Descripción del modelo: {model['description']}\n" text += f"Tipo de modelo: {model['model_type']}\n\n" return [types.TextContent(type="text", text=text)] async def get_model_tool(arguments: dict): """ Dado un ID de modelo y un mensaje de usuario, obtenga una respuesta de la API de Novita. """ model_id = arguments.get("model_id") message = arguments.get("message") if not model_id or not message: raise ValueError("Se requieren tanto 'model_id' como 'message'.") 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]: si nombre == "list_models": devolver await list_models_tool() si nombre == "get_model": devolver await get_model_tool(arguments) de lo contrario: generar ValueError(f"Herramienta desconocida: {name}") @app.list_tools() async def list_tools() -> list[types.Tool]: devolver [ types.Tool( name="list_models", description="Enumerar todos los modelos disponibles de la API de Novita.", inputSchema={"type": "object", "properties": {}}, ), types.Tool( name="get_model", description="Proporcione un ID de modelo y un mensaje para obtener una respuesta de la API de Novita.", inputSchema={ "type": "object", "required": ["model_id", "message"], "properties": { "model_id": { "type": "string", "description": "El ID del modelo que se usará.", }, "mensaje": { "tipo": "cadena", "descripción": "El mensaje de entrada a enviar.", }, }, }, ), ] async def main(): async con stdio_server() como streams: await app.run(streams[0], streams[1], app.create_initialization_options()) si __name__ == "__main__": asyncio.run(main())

El servidor de bajo nivel no solo le brinda un control detallado sobre la administración de herramientas; también proporciona control de bajo nivel sobre recursos, indicaciones y otras partes del protocolo MCP, como la administración del ciclo de vida.

Conclusión

En este tutorial, creamos un servidor MCP que utiliza la API de Novita para optimizar las capacidades de cualquier host MCP. Aprendió los fundamentos de la creación de un servidor MCP, incluyendo la definición y la exposición de herramientas.

Con esta base, puede comenzar a explorar temas más avanzados, como la autenticación, la implementación de servidores MCP remotos y el trabajo directo con la implementación de Python de bajo nivel.

También exploramos la API de Novita y vimos sus capacidades, desde un conjunto diverso de modelos de lenguaje hasta herramientas de generación de video, audio e imágenes. Visite Anuncios LLM Playground para probar otras API que no pudimos cubrir tan bien, como los puntos finales del editor de imágenes y rostros.

Novita AI es una plataforma de nube de IA que ofrece a los desarrolladores una manera fácil de implementar modelos de IA utilizando nuestra API simple, al mismo tiempo que proporciona un servicio asequible y confiable. GPU Nube para construir y escalar.