Mistral AI API
Referencia de Integración

from mistralai import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def generar_email_seguimiento(
    nombre_cliente: str,
    empresa: str,
    ultima_reunion: str,
    servicio_propuesto: str
) -> str:
    """Genera un email de seguimiento personalizado para CultivaCRM."""

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": (
                    "Eres el asistente comercial de CultivaCRM. "
                    "Redactas emails profesionales en español, "
                    "cálidos y orientados a resultados. Sin clichés."
                )
            },
            {
                "role": "user",
                "content": f"Escribe un email de seguimiento para {nombre_cliente} "
                           f"de {empresa}. Última reunión: {ultima_reunion}. "
                           f"Servicio discutido: {servicio_propuesto}."
            }
        ],
    )

    return response.choices[0].message.content


# --- Uso en CultivaCRM ---
email = generar_email_seguimiento(
    nombre_cliente="Ana García",
    empresa="Agencia Momentum Madrid",
    ultima_reunion="14 jun 2026 — demo de automatización de campañas",
    servicio_propuesto="Plan Growth: automatización + IA de leads (890€/mes)"
)

print(email)
# → Asunto: Siguientes pasos tras nuestra demo de ayer, Ana
# → Hola Ana, ha sido un placer mostrarte cómo Cultiva...

from mistralai import Mistral
import json

client = Mistral()

def clasificar_lead(mensaje_formulario: str) -> dict:
    """
    Extrae datos estructurados de un formulario de contacto en lenguaje libre.
    Devuelve JSON con sector, presupuesto, urgencia y servicio.
    """
    response = client.chat.complete(
        model="mistral-small-latest",  # económico para alto volumen
        messages=[
            {
                "role": "user",
                "content": (
                    "Analiza este mensaje de contacto y devuelve JSON con los campos: "
                    "sector (string), presupuesto_eur (number o null), urgencia (alta/media/baja), "
                    "servicio_solicitado (string), tamanyo_empresa (string). "
                    f"Mensaje: {mensaje_formulario}"
                )
            }
        ],
        response_format={"type": "json_object"},
    )

    return json.loads(response.choices[0].message.content)


# --- Formulario de contacto recibido en CultivaCRM ---
formulario = """
Hola, somos una clínica dental con 3 centros en Barcelona.
Llevamos tiempo queriendo mejorar nuestra presencia digital
y automatizar el seguimiento de pacientes. Tenemos unos
800 pacientes activos. Presupuesto orientativo unos 600€ al mes,
aunque podemos llegar a 1000 si el ROI lo justifica.
Necesitamos empezar antes de septiembre si es posible.
"""

lead = clasificar_lead(formulario)
print(json.dumps(lead, indent=2, ensure_ascii=False))
"""
{
  "sector": "Salud / Clínica dental",
  "presupuesto_eur": 800,
  "urgencia": "alta",
  "servicio_solicitado": "Presencia digital + automatización CRM",
  "tamanyo_empresa": "Mediana (3 centros, ~800 pacientes)"
}
"""

from mistralai import Mistral
import numpy as np
from typing import List, Dict

client = Mistral()

def get_embedding(texto: str) -> List[float]:
    """Genera embedding de 1024 dimensiones con mistral-embed."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[texto]
    )
    return response.data[0].embedding

def cosine_similarity(a, b) -> float:
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def buscar_clientes_similares(
    nuevo_prospecto: str,
    base_clientes: List[Dict],
    top_k: int = 3
) -> List[Dict]:
    """
    Encuentra los top_k clientes más similares al nuevo prospecto.
    Útil para incluir casos de éxito relevantes en la propuesta.
    """
    embedding_prospecto = get_embedding(nuevo_prospecto)

    resultados = []
    for cliente in base_clientes:
        emb = get_embedding(cliente["descripcion"])
        score = cosine_similarity(embedding_prospecto, emb)
        resultados.append({**cliente, "similitud": round(score, 3)})

    return sorted(resultados, key=lambda x: x["similitud"], reverse=True)[:top_k]


# --- Base de clientes de CultivaCRM (ejemplo) ---
base = [
    {"nombre": "Clínica DentalPro", "descripcion": "Clínica dental 2 centros Madrid, automatización citas"},
    {"nombre": "E-commerce ModaKid", "descripcion": "Tienda online moda infantil, email marketing"},
    {"nombre": "Consultora Nexum", "descripcion": "Consultoría estratégica B2B, generación de leads"},
    {"nombre": "FisioBalance", "descripcion": "Centro fisioterapia 4 sedes, CRM pacientes, WhatsApp"},
]

prospecto = "Clínica dental 3 centros Barcelona, quieren automatizar seguimiento de pacientes"
similares = buscar_clientes_similares(prospecto, base, top_k=2)
print(similares)
# → [{"nombre": "Clínica DentalPro", "similitud": 0.941, ...},
#     {"nombre": "FisioBalance", "similitud": 0.873, ...}]

from mistralai import Mistral

client = Mistral()

# Fill-in-the-middle: el dev escribe prefijo y sufijo,
# Codestral genera el cuerpo de la función.
response = client.fim.complete(
    model="codestral-latest",
    prompt="""
def calcular_score_lead(lead: dict) -> float:
    \"\"\"
    Calcula un score de 0-100 para priorizar leads en CultivaCRM.
    Factores: presupuesto, urgencia, tamaño empresa, sector.
    \"\"\"
""",
    suffix="""

# Tests básicos
assert calcular_score_lead({"presupuesto_eur": 2000, "urgencia": "alta"}) > 70
assert calcular_score_lead({"presupuesto_eur": 100, "urgencia": "baja"}) < 30
""",
    max_tokens=512,
)

codigo_generado = response.choices[0].message.content
print(codigo_generado)
"""
    score = 0.0
    if lead.get("presupuesto_eur"):
        score += min(lead["presupuesto_eur"] / 50, 40)  # max 40pts
    urgencia_pts = {"alta": 30, "media": 15, "baja": 5}
    score += urgencia_pts.get(lead.get("urgencia", "baja"), 0)
    ...
    return min(score, 100.0)
"""


# --- TypeScript: streaming en el editor web del CRM ---

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

/** Genera sugerencia de código en streaming para el editor del CRM */
export async function* streamCodeSuggestion(
  prompt: string,
  onChunk: (chunk: string) => void
): AsyncGenerator<string> {
  const stream = await client.chat.stream({
    model: "codestral-latest",
    messages: [
      { role: "user", content: prompt }
    ],
  });

  for await (const event of stream) {
    const chunk = event.data.choices[0]?.delta?.content ?? "";
    if (chunk) {
      onChunk(chunk);
      yield chunk;
    }
  }
}

// Uso en componente React del editor CRM:
// for await (const chunk of streamCodeSuggestion(prompt, setCode)) {}