RAG

import math
import anthropic

MODEL = "claude-sonnet-5-5"
client = anthropic.Anthropic()

def embed(textos: list[str]) -> list[list[float]]:
    """Usa el proveedor de embeddings que prefieras."""
    raise NotImplementedError

def coseno(a: list[float], b: list[float]) -> float:
    num = sum(x * y for x, y in zip(a, b))
    return num / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))

# Indexación (una vez)
FRAGMENTOS = [
    {"id": "dev-1", "fuente": "politicas.md#devoluciones", "texto": "Las devoluciones se aceptan hasta 30 días después de la entrega."},
    {"id": "env-1", "fuente": "politicas.md#envios", "texto": "Los envíos peninsulares tardan entre 48 y 72 horas laborables."},
]
VECTORES = embed([f["texto"] for f in FRAGMENTOS])

def recuperar(pregunta: str, k: int = 4) -> list[dict]:
    q = embed([pregunta])[0]
    puntuados = sorted(zip(FRAGMENTOS, VECTORES), key=lambda fv: coseno(q, fv[1]), reverse=True)
    return [f for f, _ in puntuados[:k]]

def responder(pregunta: str) -> str:
    fragmentos = recuperar(pregunta)
    contexto = "\n".join(
        f'<fragmento id="{f["id"]}" fuente="{f["fuente"]}">{f["texto"]}</fragmento>' for f in fragmentos
    )
    resp = client.messages.create(
        model=MODEL,
        max_tokens=600,
        system=(
            "Responde solo con la información de <fragmentos>. Cita el id entre corchetes, p. ej. [dev-1]. "
            "Si los fragmentos no contienen la respuesta, di que no lo sabes."
        ),
        messages=[{"role": "user", "content": f"<fragmentos>\n{contexto}\n</fragmentos>\n\nPregunta: {pregunta}"}],
    )
    return "".join(b.text for b in resp.content if b.type == "text")

import Anthropic from "@anthropic-ai/sdk";

const MODEL = "claude-sonnet-5-5";
const client = new Anthropic();

type Fragmento = { id: string; fuente: string; texto: string };

async function embed(textos: string[]): Promise<number[][]> {
  // Usa el proveedor de embeddings que prefieras.
  throw new Error("No implementado");
}

function coseno(a: number[], b: number[]): number {
  const num = a.reduce((s, x, i) => s + x * b[i], 0);
  const na = Math.sqrt(a.reduce((s, x) => s + x * x, 0));
  const nb = Math.sqrt(b.reduce((s, x) => s + x * x, 0));
  return num / (na * nb);
}

const FRAGMENTOS: Fragmento[] = [
  { id: "dev-1", fuente: "politicas.md#devoluciones", texto: "Las devoluciones se aceptan hasta 30 días después de la entrega." },
  { id: "env-1", fuente: "politicas.md#envios", texto: "Los envíos peninsulares tardan entre 48 y 72 horas laborables." },
];
const VECTORES = await embed(FRAGMENTOS.map((f) => f.texto));

async function recuperar(pregunta: string, k = 4): Promise<Fragmento[]> {
  const [q] = await embed([pregunta]);
  return FRAGMENTOS.map((f, i) => ({ f, s: coseno(q, VECTORES[i]) }))
    .sort((a, b) => b.s - a.s)
    .slice(0, k)
    .map((x) => x.f);
}

async function responder(pregunta: string): Promise<string> {
  const fragmentos = await recuperar(pregunta);
  const contexto = fragmentos
    .map((f) => `<fragmento id="${f.id}" fuente="${f.fuente}">${f.texto}</fragmento>`)
    .join("\n");
  const resp = await client.messages.create({
    model: MODEL,
    max_tokens: 600,
    system:
      "Responde solo con la información de <fragmentos>. Cita el id entre corchetes, p. ej. [dev-1]. " +
      "Si los fragmentos no contienen la respuesta, di que no lo sabes.",
    messages: [{ role: "user", content: `<fragmentos>\n${contexto}\n</fragmentos>\n\nPregunta: ${pregunta}` }],
  });
  return resp.content.map((b) => (b.type === "text" ? b.text : "")).join("");
}