Arquitectura de FastAPI y caso de uso B2B

Qué es FastAPI y para qué sirve

FastAPI es un framework web de Python orientado a construir APIs HTTP con rendimiento alto, validación automática de datos y documentación interactiva generada desde el propio código. Se apoya en dos dependencias principales: Starlette como capa ASGI (enrutamiento, middleware, WebSockets) y Pydantic v2 para validación y serialización. Esta combinación lo sitúa entre los frameworks Python más rápidos del mercado, con latencias comparables a Node.js y Go en cargas de I/O.

En entornos B2B, FastAPI es el framework de referencia para exponer servicios de inferencia de modelos de machine learning, APIs de analítica sobre almacenes de datos, microservicios de scoring crediticio, endpoints RAG que sirven respuestas a partir de documentación interna y servicios de pricing dinámico que responden a ERPs o frontales web en milisegundos.

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(title="Servicio de scoring", version="1.0")

class Solicitud(BaseModel):
    cliente_id: str = Field(min_length=3)
    ingresos: float = Field(ge=0)
    deuda: float = Field(ge=0)

@app.post("/scoring")
async def calcular_score(datos: Solicitud) -> dict:
    ratio = datos.deuda / max(datos.ingresos, 1.0)
    score = max(0, 100 - ratio * 100)
    return {"cliente_id": datos.cliente_id, "score": round(score, 2)}

Con menos de veinte líneas de código, FastAPI valida el cuerpo de la petición, rechaza automáticamente entradas mal formadas con un error 422 detallado y pública un panel Swagger en /docs que los equipos de producto y QA pueden usar sin instalar herramientas adicionales.

Arquitectura y flujo de una petición

Una petición entra por el servidor ASGI (Uvicorn o Hypercorn), Starlette la enruta al endpoint, Pydantic valida el cuerpo y los parámetros, el sistema de dependencias inyecta sesiones de base de datos o clientes HTTP, y la respuesta se serializa automáticamente a JSON según el modelo declarado.

flowchart LR
    Cliente[Cliente HTTP] --> Uvicorn[Uvicorn ASGI]
    Uvicorn --> Starlette[Starlette routing]
    Starlette --> Pydantic[Pydantic v2 validation]
    Pydantic --> DI[Dependency Injection]
    DI --> Logic[Lógica de negocio]
    Logic --> Response[Respuesta serializada JSON]
    Starlette --> OpenAPI[OpenAPI 3.1 docs]

Características clave

Validación automática con anotaciones de tipo. FastAPI lee las anotaciones de Python y construye validadores en tiempo de arranque. Los errores de entrada devuelven un 422 estandarizado con el campo y el motivo del fallo, sin código manual de parsing.

Documentación interactiva sin esfuerzo. El framework genera un documento OpenAPI 3.1 a partir de las firmas de las funciones y los modelos Pydantic, y lo expone en Swagger UI (/docs) y ReDoc (/redoc). Esto reduce fricción con equipos consumidores y acelera integraciones entre microservicios.

Async/await nativo. Las rutas declaradas con async def liberan el hilo durante operaciones de I/O (consultas a base de datos, llamadas a APIs externas, inferencia remota), lo que permite manejar miles de conexiones concurrentes por proceso.

Inyección de dependencias. El sistema Depends permite definir recursos compartidos (sesiones de base de datos, clientes HTTP, usuarios autenticados) y sustituirlos en tests sin refactorizar el código de producción.

Compatible con el stack Python moderno. Se integra de forma natural con SQLAlchemy async, Redis, Kafka, scikit-learn, LangChain, Pydantic Settings y herramientas de observabilidad como OpenTelemetry.

Caso B2B: endpoint de clasificación de tickets

Un servicio de soporte recibe decenas de miles de tickets al día y necesita enrutarlos a la cola correcta (facturación, técnico, ventas). Con FastAPI se expone un modelo scikit-learn cargado en memoria como un endpoint que responde en pocos milisegundos y queda documentado automáticamente para que el sistema de tickets lo consuma.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI(title="Clasificador de tickets")
modelo = joblib.load("clasificador_tickets.joblib")

class Ticket(BaseModel):
    asunto: str
    cuerpo: str

@app.post("/clasificar")
async def clasificar(ticket: Ticket) -> dict:
    texto = f"{ticket.asunto} {ticket.cuerpo}"
    categoria = modelo.predict([texto])[0]
    probabilidad = float(modelo.predict_proba([texto]).max())
    return {"categoria": categoria, "confianza": round(probabilidad, 3)}

En las próximas lecciones se cubre la instalación del framework, la creación de una aplicación mínima y la estructura que debe seguir un proyecto FastAPI para escalar desde un prototipo hasta un microservicio desplegado en Kubernetes.