Construyendo una API LLM de alto rendimiento y lista para producción con FastAPI: Una guía paso a paso

FastAPI, como un framework web de Python moderno y de alto rendimiento, es popular por su facilidad de uso, velocidad y documentación de API generada automáticamente. Especialmente en la construcción de APIs backend para aplicaciones LLM (Large Language Model), FastAPI demuestra una poderosa ventaja. Este artículo te enseñará paso a paso cómo construir una API LLM lista para producción utilizando FastAPI, y explorará algunas de las mejores prácticas.

¿Por qué elegir FastAPI?

Al construir la API de una aplicación LLM, FastAPI ofrece las siguientes ventajas clave:

• Alto rendimiento: Basado en ASGI, FastAPI puede manejar solicitudes de alta concurrencia, lo cual es crucial para aplicaciones LLM que requieren respuestas rápidas.
• Soporte asíncrono: FastAPI tiene soporte incorporado para las palabras clave async y await, lo que facilita el manejo de operaciones asíncronas, como llamar a la inferencia LLM, evitando el bloqueo del hilo principal.
• Documentación automática de la API: FastAPI utiliza OpenAPI y JSON Schema para generar automáticamente documentación de API interactiva (Swagger UI), lo que facilita a los desarrolladores probar y usar tu API.
• Validación de datos: FastAPI utiliza Pydantic para la validación de datos, asegurando la corrección de los parámetros de la solicitud y reduciendo errores.
• Inyección de dependencias: El sistema de inyección de dependencias de FastAPI facilita la gestión y el intercambio de recursos, como los modelos LLM.
• Comunidad activa: FastAPI tiene una comunidad grande y activa, donde puedes obtener abundantes recursos y soporte.

Preparación

1. Instalar Python: Asegúrate de tener instalado Python 3.7 o superior.

2. Instalar FastAPI y Uvicorn: Usa pip para instalar FastAPI y Uvicorn (servidor ASGI):

   pip install fastapi uvicorn
   

3. Elegir un modelo LLM: Elige el modelo LLM que deseas utilizar. Puede ser un modelo de OpenAI, o un modelo de código abierto, como TinyLlama. Si eliges OpenAI, necesitas obtener una clave API de OpenAI. Si eliges TinyLlama, necesitas descargar el archivo del modelo.

Paso 1: Crear una aplicación FastAPI

Crea un archivo llamado main.py y añade el siguiente código:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="Una API simple para interactuar con LLMs.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

Este código define una aplicación FastAPI, y define dos modelos Pydantic: InputText para recibir el texto de entrada, y OutputText para retornar el texto generado.

Paso 2: Añadir la lógica de inferencia LLM

De acuerdo con el modelo LLM que elijas, añade la lógica de inferencia correspondiente. Aquí se toma como ejemplo el uso de la API de OpenAI:

import openai
import os

# Obtener la clave API de OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Se recomienda usar variables de entorno
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using OpenAI.
    """
    try:
        response = openai.Completion.create(
            engine="text-davinci-003", # Selecciona el modelo
            prompt=input_text.text,
            max_tokens=150,
            n=1,
            stop=None,
            temperature=0.7,
        )
        generated_text = response.choices[0].text.strip()
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Este código define una ruta /generate que recibe un objeto InputText como entrada, llama a la API de OpenAI para generar texto y devuelve el texto generado como un objeto OutputText. Ten en cuenta que debes reemplazar text-davinci-003 con el modelo apropiado que elijas.

Si utilizas un modelo local como TinyLlama, necesitas instalar la biblioteca correspondiente, por ejemplo, transformers, y cargar el modelo en la memoria. El ejemplo de código es el siguiente:

from transformers import pipeline
import torch

generator = pipeline('text-generation', model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", torch_dtype=torch.bfloat16, device_map="auto")

@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using TinyLlama.
    """
    try:
        generated_text = generator(input_text.text, max_length=50, do_sample=True, temperature=0.7)[0]['generated_text']
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Paso 3: Ejecutar la aplicación FastAPI

Ejecuta la aplicación FastAPI usando Uvicorn:

uvicorn main:app --reload
```Esto iniciará un servidor local, al que puedes acceder en tu navegador en `http://127.0.0.1:8000/docs` para ver la documentación de la API generada automáticamente. El parámetro `--reload` puede reiniciar automáticamente el servidor después de modificar el código, lo que facilita el desarrollo. 

## Paso 4: Probar la API

Usa la documentación de la API o herramientas como curl para probar tu API. Por ejemplo, usa curl para enviar una solicitud POST:

```bash
curl -X POST -H "Content-Type: application/json" -d '{"text": "Tell me a joke about cats."}' http://127.0.0.1:8000/generate

Deberías recibir una respuesta JSON que contenga el texto generado.

Paso 5: Despliegue en producción

Despliega la aplicación FastAPI en un entorno de producción, por ejemplo:

• Docker: Usa Docker para contenerizar tu aplicación, facilitando el despliegue y la gestión.
• Plataforma en la nube: Despliega en una plataforma en la nube, como AWS, Google Cloud Platform o Azure. Azure Cosmos DB y Azure Functions, mencionados en el texto, se pueden usar para construir una API serverless. Modal también se puede usar para desplegar aplicaciones FastAPI de escalado automático.
• Servidor: Despliega en tu propio servidor.

Mejores prácticas

• Usa variables de entorno para almacenar información sensible: No codifiques claves API u otra información sensible directamente en el código. En su lugar, usa variables de entorno.
• Añade registro (logging): Usa el módulo de registro para registrar el estado de ejecución de la API, facilitando la depuración y la monitorización.
• Añade manejo de errores: Usa bloques try...except para manejar las excepciones que puedan ocurrir y devolver información de error adecuada.
• Limitación de velocidad (Rate limiting): Usa un limitador de velocidad para evitar el abuso de la API. FastAPI tiene algunas bibliotecas de limitación de velocidad disponibles.
• Caché: Para solicitudes repetidas, puedes usar la caché para mejorar el rendimiento.
• Monitorización: Usa herramientas de monitorización para monitorizar el rendimiento y la disponibilidad de la API.

Trucos avanzados

• Procesamiento asíncrono: Para la inferencia LLM que consume mucho tiempo, usa las palabras clave async y await para el procesamiento asíncrono, evitando el bloqueo del hilo principal.
• Respuesta en streaming: Usar una respuesta en streaming (StreamingResponse) puede devolver el texto generado en tiempo real, mejorando la experiencia del usuario.
• Multihilo/Multiproceso: Para la inferencia LLM intensiva en CPU, puedes usar multihilo o multiproceso para mejorar el rendimiento.
• Aceleración por GPU: Si tu modelo LLM admite la aceleración por GPU, puedes usar CUDA u otras bibliotecas de aceleración por GPU para aumentar la velocidad de inferencia.

ConclusiónFastAPI es una herramienta poderosa para construir APIs de LLM de alto rendimiento y listas para producción. A través de esta guía, puedes configurar rápidamente una API de LLM y expandirla y optimizarla según tus necesidades. Recuerda, el aprendizaje continuo y la práctica son clave para convertirte en un excelente desarrollador de aplicaciones LLM. Hornbeam, mencionado en el artículo, también es un servidor ASGI que vale la pena considerar, que afirma ser más rápido y estable que Gunicorn, y puede usarse para implementar aplicaciones FastAPI.