¿Cómo integrar FastAPI con modelos de Machine Learning y Cohere para crear aplicaciones inteligentes?

Cuando hablamos de integrar FastAPI con modelos de Machine Learning (ML) y APIs como Cohere, estamos ante la oportunidad de crear aplicaciones web potentes que aprovechan la inteligencia artificial para ofrecer servicios innovadores, como diagnósticos médicos o asistentes conversacionales. Este tipo de integración no solo mejora la experiencia del usuario, sino que también permite crear aplicaciones que responden de manera inteligente a consultas complejas, adaptándose al contexto de la conversación o a la información proporcionada.

En el código proporcionado, se muestra cómo configurar un endpoint GET /diagnosis en FastAPI que recibe los síntomas de un paciente como parámetros. Los síntomas se manejan como objetos dinámicos generados con la ayuda de la biblioteca Pydantic. Este enfoque permite que el número de parámetros sea flexible, ya que puede ser modificado fácilmente dependiendo de la cantidad de síntomas que queramos incluir en la consulta. En este caso, se restringe el modelo para aceptar solo los primeros diez síntomas de una lista predefinida.

El código de la integración con FastAPI comienza con la creación de un modelo de síntomas mediante la función create_model de Pydantic. Esto se hace utilizando un diccionario donde cada clave corresponde a un síntoma, y el valor asociado es un booleano que indica si el síntoma está presente o no. Luego, se crea el endpoint /diagnosis que recibe estos parámetros, los convierte en un arreglo y los pasa al modelo de ML para obtener el diagnóstico. El modelo de ML, que es un modelo de predicción previamente entrenado, devuelve un conjunto de posibles enfermedades, que se devuelven como una respuesta estructurada.

Este tipo de integración es útil para cualquier aplicación que necesite una interfaz rápida y eficiente para hacer predicciones basadas en un conjunto de datos. Al integrar FastAPI con modelos de ML, como en el ejemplo anterior, podemos crear aplicaciones interactivas que permitan a los usuarios ingresar datos y recibir respuestas precisas en tiempo real.

En el caso de Cohere, la integración con FastAPI permite crear un chatbot especializado, como un asistente culinario que sugiere recetas italianas. Para ello, se utiliza un modelo de Cohere entrenado en comprensión y generación de texto. La configuración del chatbot comienza con la creación de un mensaje del sistema que define el comportamiento del asistente, especificando que debe actuar como un chef experto en la cocina italiana. Luego, mediante el uso de la API de Cohere, se envía la consulta del usuario al modelo, que responde con sugerencias y consejos culinarios.

El proceso de integración con Cohere es sencillo. Después de obtener una clave API desde el dashboard de Cohere, es necesario cargarla en el entorno de la aplicación y configurarla utilizando una librería como python-dotenv. Esto permite acceder a las variables de entorno de manera segura. Una vez configurado el cliente de Cohere, podemos enviar consultas al modelo, definir el comportamiento del chatbot y gestionar la conversación en curso. Este tipo de funcionalidad es ideal para aplicaciones que requieren interacción en lenguaje natural, como asistentes virtuales o sistemas de recomendación.

Por último, una parte fundamental de la integración de FastAPI con Cohere y otros modelos de ML es garantizar la correcta gestión de los datos. Es esencial asegurarse de que las claves API no sean expuestas en el código fuente, especialmente si se utiliza un sistema de control de versiones como Git. Además, se deben instalar y configurar correctamente todas las dependencias necesarias para que la integración sea exitosa. Las bibliotecas principales que se requieren incluyen fastapi, uvicorn, cohere, y python-dotenv, que son fundamentales para la correcta ejecución de la aplicación.

El entendimiento y la capacidad para gestionar estos aspectos es crucial para poder desarrollar aplicaciones basadas en IA que sean escalables y seguras. La correcta configuración del entorno de desarrollo, así como la integración efectiva con modelos y APIs, permitirá crear aplicaciones poderosas que no solo responden a las necesidades del usuario, sino que también se adaptan a su contexto de manera inteligente.

¿Cómo desarrollar middleware para modificar respuestas y manejar CORS en FastAPI?

El desarrollo de middleware para modificar las respuestas HTTP es una de las herramientas más útiles al trabajar con aplicaciones web. En el contexto de FastAPI, podemos implementar middleware personalizado que permita modificar los encabezados de las respuestas antes de que se envíen al cliente. Esto es especialmente útil cuando necesitamos agregar información adicional, como encabezados personalizados, o realizar ajustes de seguridad o personalización a nivel de respuesta.

python
Copy code
class ExtraHeadersResponseMiddleware:
    def __init__(self, app: ASGIApp, headers: Sequence[tuple[str, str]]):
        self.app = app
        self.headers = headers

python
Copy code
async def __call__(self, scope: Scope, receive: Receive, send: Send):
    if scope["type"] != "http":
        return await self.app(scope, receive, send)

python
Copy code
async def send_with_extra_headers(message: Message):
    if message["type"] == "http.response.start":
        headers = MutableHeaders(scope=message)
        for key, value in self.headers:
            headers.append(key, value)
    await send(message)

El último paso consiste en agregar el middleware a la instancia de FastAPI. Esto se logra mediante el método add_middleware, pasando el middleware recién creado junto con los encabezados a agregar a las respuestas. Un ejemplo de cómo hacer esto sería:

python
Copy code
app.add_middleware(

    ExtraHeadersResponseMiddleware,
    headers=(
        ("new-header", "fastapi-cookbook"),
        ("another-header", "fastapi-cookbook"),
    ),
)

Al probar esta implementación, si ejecutamos el servidor y consultamos los encabezados de la respuesta, deberíamos ver los nuevos encabezados añadidos a los predeterminados, como "new-header" y "another-header". Así, hemos creado un middleware que permite modificar las respuestas de nuestra API.

Manejo de CORS con Middleware

Para manejar CORS en FastAPI, podemos utilizar el middleware CORSMiddleware proporcionado por Starlette. Este middleware permite especificar qué orígenes están autorizados a hacer solicitudes a la API, qué métodos HTTP son aceptados y qué encabezados pueden ser enviados con las solicitudes. La configuración básica para permitir solicitudes CORS de cualquier origen podría ser la siguiente:

python
Copy code
from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Permite cualquier origen
    allow_methods=["*"],  # Permite cualquier método HTTP
    allow_headers=["*"],  # Permite cualquier encabezado
)

Si bien en desarrollo es común permitir todos los orígenes y métodos, en producción es esencial configurar estos parámetros con más rigor para asegurar que solo los orígenes de confianza puedan acceder a la API.

Además de configurar el middleware de CORS, podemos realizar pruebas prácticas usando una página HTML simple que haga solicitudes a nuestra API. Al abrir la página en un navegador y enviar una solicitud, se puede observar cómo, si CORS no está configurado correctamente, el navegador bloquea la solicitud con un mensaje de error indicando que la política de CORS no permite el acceso desde el origen indicado.

Restricción de solicitudes entrantes desde dominios específicos

En términos de seguridad, restringir las solicitudes a ciertos orígenes o hosts es una práctica importante para proteger nuestras aplicaciones contra ataques de DNS rebinding y otras amenazas. FastAPI ofrece una solución en forma de TrustedHostMiddleware, que nos permite especificar qué hosts están permitidos para interactuar con la API. Cualquier solicitud proveniente de un host no autorizado será rechazada.

La implementación de este middleware en FastAPI es sencilla. Al agregar el TrustedHostMiddleware a nuestra aplicación, podemos definir una lista de hosts confiables desde los cuales se aceptarán solicitudes. Si una solicitud proviene de un origen no autorizado, FastAPI la rechazará con un error 400. A continuación se muestra cómo se puede agregar este middleware:

python
Copy code
from fastapi.middleware.trustedhost import TrustedHostMiddleware

app.add_middleware(
    TrustedHostMiddleware,
    allowed_hosts=["localhost", "example.com"],
)

En este ejemplo, solo las solicitudes provenientes de localhost o example.com serán aceptadas. Las solicitudes de otros dominios serán rechazadas, lo que refuerza la seguridad de la aplicación al evitar accesos no autorizados desde dominios desconocidos.