IA Financiera en tiempo real: domina inflación y volatilidad

IA Financiera en tiempo real: cómo combatir la inflación y la volatilidad con asistentes inteligentes

---

Introducción

La inflación y la volatilidad de los mercados ya no son solo cifras en los periódicos; están golpeando el bolsillo de hogares y pymes cada día. En los últimos meses, búsquedas como “budget AI” o “ahorro con IA” han explotado en Google Trends, y foros como Reddit y Hacker News se llenan de preguntas sobre cómo automatizar la gestión del dinero con los nuevos modelos de OpenAI, Google Gemini y los conectores bancarios de Plaid.

Este artículo te muestra, paso a paso y con ejemplos de código listos para copiar, cómo montar tu propio asistente financiero con Python, FastAPI y Streamlit. También analizaremos la arquitectura, compararemos las principales soluciones del mercado, y entregaremos un checklist de seguridad y una tabla de precios para que decidas si lanzar tu SaaS o adoptar una herramienta existente.

---

1. Arquitectura básica de un asistente financiero

┌─────────────────────┐      ┌─────────────────────┐
│  Front‑end (Streamlit)│──►│  API de negocio (FastAPI)│
└─────────▲─────────────┘      └───────▲───────────────┘
          │                           │
          │   Llamada a LLM (OpenAI/   │
          │   Gemini) + Plaid SDK      │
          ▼                           ▼
┌─────────────────────┐      ┌─────────────────────┐
│  Modelo de lenguaje │      │  Conector bancario │
│  (GPT‑4o, Gemini)   │      │  (Plaid, TrueLayer)│
└─────────────────────┘      └─────────────────────┘

1. Streamlit captura la pregunta del usuario en lenguaje natural.
2. FastAPI orquesta la llamada al LLM y, si es necesario, a la API de Plaid para obtener transacciones.
3. El LLM interpreta la petición, genera la lógica de negocio (por ejemplo, cálculo de ahorro) y devuelve una respuesta estructurada.
4. Opcionalmente, FastAPI ejecuta acciones bancarias (transferencias, cancelación de suscripciones) mediante los endpoints de Plaid, siempre bajo autorización del cliente.

---

2. Comparativa rápida de las soluciones líderes

Característica	OpenAI GPT‑4o	Google Gemini 1.5	Plaid Transactions	TrueLayer	Fintecture
Modelo de lenguaje	175 B parámetros	120 B parámetros	–	–	–
Soporte de function calling	✅	✅	–	–	–
Precio (por 1 000 tokens)	$0.03 entrada / $0.06 salida	$0.02 entrada / $0.04 salida	$0.30 por usuario/mes	$0.25 por usuario/mes	$0.28 por usuario/mes
Latencia media	~120 ms	~150 ms	~200 ms	~180 ms	~210 ms
Cumplimiento PSD2 / GDPR	✅	✅	✅	✅	✅
SDK oficial (Python)	openai	google-generativeai	plaid-python	truelyzer	fintecture-sdk

Tip: Si tu caso de uso necesita function calling (por ejemplo, generar una tabla de gastos), GPT‑4o y Gemini son los únicos que lo soportan de forma nativa.

---

3. Tutorial paso a paso

3.1. Preparar el entorno

# Crear entorno virtual
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# Instalar dependencias
pip install fastapi uvicorn streamlit openai google-generativeai plaid-python python-dotenv

Crea un archivo .env con tus credenciales (nunca lo subas a Git):

OPENAI_API_KEY=sk-...
GEMINI_API_KEY=...
PLAID_CLIENT_ID=...
PLAID_SECRET=...
PLAID_ENV=sandbox

3.2. FastAPI: endpoint que combina LLM y Plaid

# api/main.py
import os
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import openai, google.generativeai as genai
import plaid
from plaid.api import plaid_api
from plaid.model.products import Products
from plaid.model.country_code import CountryCode
from dotenv import load_dotenv

load_dotenv()
app = FastAPI()

# --- Configuración Plaid ---
configuration = plaid.Configuration(
    host=plaid.Environment.Sandbox,
    api_key={
        "clientId": os.getenv("PLAID_CLIENT_ID"),
        "secret": os.getenv("PLAID_SECRET"),
    },
)
client = plaid_api.PlaidApi(plaid.ApiClient(configuration))

# --- Modelos de petición ---
class Query(BaseModel):
    user_id: str          # identificador interno
    question: str

# --- Helper: obtener transacciones ---
def get_transactions(access_token: str, start_date: str, end_date: str):
    request = plaid.model.TransactionsGetRequest(
        access_token=access_token,
        start_date=start_date,
        end_date=end_date,
        options=plaid.model.TransactionsGetRequestOptions(count=100),
    )
    response = client.transactions_get(request)
    return [t.to_dict() for t in response["transactions"]]

# --- Endpoint principal ---
@app.post("/ask")
async def ask(query: Query):
    # 1️⃣ Obtener token de Plaid (en producción lo guardas en DB)
    # Aquí usamos un token de sandbox estático para demo
    access_token = "sandbox-access-token"

    # 2️⃣ Recuperar últimas 30 días de transacciones
    txs = get_transactions(access_token, "2024-08-01", "2024-08-31")

    # 3️⃣ Construir prompt para el LLM
    prompt = f"""
    Eres un asistente financiero. El usuario pregunta: "{query.question}"
    Usa los siguientes datos de transacciones (JSON) para responder:
    {txs[:5]}  # muestra solo 5 para evitar overflow
    Responde en español, con cifras redondeadas y sugiere una acción concreta.
    """

    # 4️⃣ Llamada a OpenAI (puedes cambiar a Gemini cambiando esta sección)
    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,
    )
    answer = response.choices[0].message.content
    return {"answer": answer}

Ejecuta el servidor:

uvicorn api.main:app --reload

3.3. Front‑end con Streamlit

# app.py
import streamlit as st
import requests
import os
from dotenv import load_dotenv

load_dotenv()
API_URL = "http://localhost:8000/ask"

st.title("💰 Asistente financiero IA")
st.caption("Pregúntale a tu IA cómo optimizar tus gastos este mes")

question = st.text_input("¿Qué quieres saber?", placeholder="Ej.: ¿Cuánto gasté en comida este mes?")

if st.button("Consultar"):
    if not question:
        st.warning("Escribe una pregunta antes de consultar")
    else:
        payload = {"user_id": "demo_user", "question": question}
        try:
            r = requests.post(API_URL, json=payload, timeout=15)
            r.raise_for_status()
            answer = r.json()["answer"]
            st.success(answer)
        except Exception as e:
            st.error(f"Error al contactar la API: {e}")

Ejecuta la UI:

streamlit run app.py

¡Listo! Ya tienes un asistente que entiende lenguaje natural, accede a tus transacciones y devuelve recomendaciones personalizadas.

---

4. Checklist de seguridad y privacidad

✅	Acción	Por qué es importante
1	Usar tokens de acceso temporales (OAuth 2.0)	Evita almacenar credenciales bancarias.
2	Cifrar datos en reposo (AES‑256)	Cumple con GDPR y protege contra brechas.
3	Habilitar MFA para usuarios y para el dashboard de administración	Reduce el riesgo de suplantación.
4	Rotar secretos cada 30 días (Vault, AWS KMS)	Limita el impacto si un token se filtra.
5	Auditar logs de llamadas a Plaid y a la LLM	Detecta acces

---

Herramienta mencionada: Groq Cloud