Integrando PostgreSQL con Inteligencia Artificial: Llamadas a APIs desde Funciones PL/pgSQL

En PostgreSQL es posible consultar un endpoint de inteligencia artificial (IA) desde un procedimiento almacenado o una función. Sin embargo, no es una funcionalidad nativa directa y requiere el uso de extensiones o soluciones intermedias.

Aquí te presento algunas maneras de lograrlo:

1. Usando la Extensión http_request:

Esta extensión te permite realizar solicitudes HTTP desde dentro de la base de datos. Puedes usarla para enviar datos al endpoint de IA y recibir la respuesta.

• Instalación: Si no la tienes instalada, puedes intentarlo con:

CREATE EXTENSION http_request;

Es posible que necesites permisos de superusuario para esto.

Ejemplo de Función:

CREATE OR REPLACE FUNCTION consultar_ia(datos JSONB)
RETURNS JSONB
AS $$
DECLARE
    url_ia TEXT := 'TU_ENDPOINT_DE_IA'; -- Reemplaza con la URL real
    respuesta_ia JSONB;
BEGIN
    SELECT content::JSONB
    INTO respuesta_ia
    FROM http_post(url_ia, 'application/json', datos);

    RETURN respuesta_ia;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

Luego podrías llamar a esta función desde un procedimiento almacenado o directamente con datos JSON:

SELECT consultar_ia('{"pregunta": "Cuál es la capital de España?"}'::JSONB);

Consideraciones al usar http_request:

• Seguridad: Ten cuidado al habilitar esta extensión, ya que permite a la base de datos realizar solicitudes a cualquier servidor. Considera restringir los permisos.
• Manejo de Errores: Deberás implementar un manejo de errores robusto para las posibles fallas en la conexión o respuestas inesperadas del endpoint de IA.
• Rendimiento: Realizar solicitudes HTTP síncronas dentro de la base de datos puede afectar el rendimiento si el endpoint de IA tiene latencia alta.

2. Usando Lenguajes Procedurales con Capacidades de Red:

PostgreSQL soporta varios lenguajes procedurales como Python (PL/Python) o Perl (PL/Perl), que tienen bibliotecas para realizar solicitudes HTTP.

• Ejemplo con PL/Python: Primero, asegúrate de tener PL/Python instalado y habilitado:

CREATE EXTENSION plpython3u;

Luego, puedes crear una función como esta:

CREATE OR REPLACE FUNCTION consultar_ia_python(datos TEXT)
RETURNS TEXT
AS $$
import requests
import json

url_ia = 'TU_ENDPOINT_DE_IA' # Reemplaza con la URL real
headers = {'Content-Type': 'application/json'}

try:
    response = requests.post(url_ia, headers=headers, data=datos)
    response.raise_for_status()  # Lanza una excepción para códigos de error HTTP
    return response.text
except requests.exceptions.RequestException as e:
    return f"Error al contactar la IA: {e}"
except json.JSONDecodeError as e:
    return f"Error al decodificar la respuesta JSON: {e}"
$$ LANGUAGE plpython3u SECURITY DEFINER;

Llamada a la función:

SELECT consultar_ia_python('{"pregunta": "Cuál es la capital de Italia?"}');

3. Arquitectura Basada en Colas de Mensajes:

Una solución más robusta y que desacopla la base de datos del endpoint de IA sería utilizar una cola de mensajes (como RabbitMQ o Kafka).

• El procedimiento almacenado o función en PostgreSQL insertaría un mensaje en la cola con los datos necesarios para la consulta a la IA.
• Un servicio separado (escrito en cualquier lenguaje) consumiría los mensajes de la cola, realizaría la llamada al endpoint de IA y luego podría almacenar el resultado en la misma base de datos o en otro lugar.

Ventajas de la Arquitectura con Colas:

• Desacoplamiento: La base de datos no tiene que esperar la respuesta del endpoint de IA, lo que mejora el rendimiento y la resiliencia.
• Escalabilidad: Puedes escalar el servicio de IA independientemente de la base de datos.
• Manejo de Fallos: Las colas de mensajes suelen tener mecanismos para reintentar o manejar mensajes fallidos.

CREATE EXTENSION plpython3u;

Luego, crea una función en PostgreSQL que publique un mensaje en una cola de RabbitMQ:

CREATE OR REPLACE FUNCTION publicar_mensaje_rabbitmq(queue_name TEXT, message TEXT)
RETURNS BOOLEAN
AS $$
import pika

# Configuración de la conexión a RabbitMQ
credentials = pika.PlainCredentials('guest', 'guest') # Reemplaza con tus credenciales
connection_parameters = pika.ConnectionParameters('localhost', # Reemplaza con la dirección de tu servidor RabbitMQ
                                                5672,
                                                '/',
                                                credentials)

try:
    connection = pika.BlockingConnection(connection_parameters)
    channel = connection.channel()

    # Declarar la cola (asegura que exista)
    channel.queue_declare(queue=queue_name, durable=True)

    # Publicar el mensaje
    channel.basic_publish(exchange='',
                          routing_key=queue_name,
                          body=message,
                          properties=pika.BasicProperties(
                              delivery_mode=2, # make message persistent
                          ))
    print(f" [x] Sent '{message}' to '{queue_name}'")
    connection.close()
    return True
except pika.exceptions.AMQPConnectionError as e:
    print(f"Error connecting to RabbitMQ: {e}")
    return False
except Exception as e:
    print(f"An error occurred: {e}")
    return False
$$ LANGUAGE plpython3u SECURITY DEFINER;

Cómo usar esta función:

SELECT publicar_mensaje_rabbitmq('mi_cola_ia', '{"pregunta": "Cuál es el clima hoy en San José?"}');

Esto llamará a la función publicar_mensaje_rabbitmq, que intentará conectar con tu servidor RabbitMQ en localhost, declarará (o se conectará a) la cola llamada mi_cola_ia, y publicará el mensaje JSON en esa cola.

Consideraciones Importantes:

• Dependencia de pika: Para que esto funcione, la biblioteca pika debe estar disponible en el entorno donde se ejecuta PL/Python en tu servidor PostgreSQL. Esto podría requerir una instalación específica en el servidor.
• Configuración de la Conexión: Asegúrate de reemplazar 'guest', 'guest' y 'localhost' con las credenciales y la dirección de tu servidor RabbitMQ.
• Manejo de Errores: El ejemplo incluye un manejo básico de errores de conexión, pero podrías necesitar una lógica más robusta para entornos de producción.
• Seguridad: Al igual que con las conexiones HTTP, considera las implicaciones de seguridad de permitir que la base de datos se conecte a un broker de mensajería.
• Transaccionalidad: Este ejemplo básico no maneja la publicación de mensajes dentro de la transacción de PostgreSQL. Si necesitas garantizar que un mensaje se publique solo si la transacción de la base de datos se confirma, necesitarías una lógica más compleja, posiblemente involucrando una tabla de «outbox» y un proceso separado que envíe los mensajes.

Ejemplo Conceptual con Kafka (usando kafka-python):

La idea sería similar con Kafka:

CREATE OR REPLACE FUNCTION publicar_mensaje_kafka(topic_name TEXT, message TEXT)
RETURNS BOOLEAN
AS $$
from kafka import KafkaProducer

try:
    producer = KafkaProducer(bootstrap_servers=['localhost:9092'], # Reemplaza con tu broker de Kafka
                             value_serializer=lambda x: x.encode('utf-8'))
    producer.send(topic_name, message)
    producer.flush() # Espera a que los mensajes se envíen
    return True
except Exception as e:
    print(f"Error sending to Kafka: {e}")
    return False
$$ LANGUAGE plpython3u SECURITY DEFINER;

SELECT publicar_mensaje_kafka('ia_requests', 'Nuevo pedido de IA');

De nuevo, las mismas consideraciones sobre dependencias, configuración, manejo de errores y seguridad aplican.

PostgreSQL no tiene una forma directa integrada de interactuar con colas de mensajes, pero puedes usar lenguajes procedurales como PL/Python junto con sus respectivas bibliotecas de cliente para lograrlo. Estas arquitecturas son más robustas para un mejor desacoplamiento y escalabilidad.