Tutorial: Compilación de una aplicación RAG

Cree una aplicación de generación aumentada por recuperación (RAG) que responda a las preguntas sobre una colección de documentos directamente en su dispositivo. RAG combina la búsqueda basada en vectores con un modelo de chat para que las respuestas se basen en sus propios datos en lugar de confiar únicamente en los fuentes de conocimiento de entrenamiento del modelo.

En este tutorial, aprenderá a:

• Configuración de un proyecto e instalación del SDK local de Foundry
• Creación de una base de conocimiento de documentos de texto
• Generación de incrustaciones para los documentos
• Buscar documentos relevantes por similitud
• Genere respuestas basadas en el contexto recuperado
• Limpieza de recursos

Requisitos previos

• Un equipo Windows, macOS o Linux con al menos 8 GB de RAM.
• Python 3.11 o posterior instalado.

Instalación de paquetes

Si estás desarrollando o distribuyendo en Windows, selecciona la pestaña Windows. El paquete de Windows se integra con el entorno de ejecución Windows ML, ofreciendo la misma superficie de API con una mayor variedad de aceleración de hardware.

Windows

pip install foundry-local-sdk-winml openai

Multiplataforma

pip install foundry-local-sdk openai

Creación de una base de conocimiento

Una aplicación RAG necesita una colección de documentos para buscar. Defina una lista de cadenas de texto que actúan como base de conocimiento. En una aplicación de producción, la lista podría ser párrafos de archivos, registros de base de datos o cualquier otro origen de texto.

Cree un archivo denominado main.py y agregue el código siguiente:

import math
from foundry_local_sdk import Configuration, FoundryLocalManager

# Knowledge base — each string represents a document
documents = [
    "Foundry Local runs AI models directly on your device without cloud connectivity.",
    "The Foundry Local SDK supports Python, C#, JavaScript, and Rust.",
    "Embedding models convert text into numerical vectors for similarity search.",
    "Foundry Local uses ONNX Runtime for efficient model inference on CPUs and GPUs.",
    "The model catalog provides pre-optimized models that you can download and run locally.",
    "Retrieval-augmented generation grounds model responses in your own data.",
    "Vector similarity search finds documents that are semantically close to a query.",
    "Chat completions generate natural language responses from a prompt and context.",
]

Generación de incrustaciones de documentos

Inicialice el SDK, cargue un modelo de inserción y convierta cada documento en un vector numérico. Estos vectores representan el significado semántico de cada documento y permiten la búsqueda de similitud.

Agregue el código siguiente a main.py:

def main():
    # Initialize the SDK
    config = Configuration(app_name="foundry_local_rag")
    FoundryLocalManager.initialize(config)
    manager = FoundryLocalManager.instance

    # Load the embedding model
    embedding_model = manager.catalog.get_model("qwen3-embedding-0.6b")
    embedding_model.download(
        lambda p: print(f"\rDownloading embedding model: {p:.1f}%", end="", flush=True)
    )
    print()
    embedding_model.load()
    embedding_client = embedding_model.get_embedding_client()

    # Embed all documents in a single batch call
    response = embedding_client.generate_embeddings(documents)
    doc_embeddings = [item.embedding for item in response.data]
    print(f"Indexed {len(doc_embeddings)} documents.")

El generate_embeddings método acepta una lista de cadenas y devuelve un vector por entrada. Cada vector captura el significado semántico del texto, por lo que los documentos similares generan vectores que están cerca en el espacio de inserción.

Buscar documentos pertinentes

Para buscar documentos relacionados con una consulta, compare los vectores de la consulta con cada vector de documento mediante la similitud de coseno. La similitud de coseno calcula la proximidad de dos vectores en cuanto a la dirección, independientemente de la magnitud. Los valores cerca de 1,0 indican una similitud alta.

Agregue las siguientes funciones auxiliares por encima de main() en main.py:

def cosine_similarity(a, b):
    """Compute cosine similarity between two vectors."""
    dot = sum(x * y for x, y in zip(a, b))
    norm_a = math.sqrt(sum(x * x for x in a))
    norm_b = math.sqrt(sum(x * x for x in b))
    return dot / (norm_a * norm_b) if norm_a and norm_b else 0.0


def find_relevant(query_embedding, doc_embeddings, top_k=2):
    """Return the indices and scores of the top-k most similar documents."""
    scores = []
    for i, doc_emb in enumerate(doc_embeddings):
        score = cosine_similarity(query_embedding, doc_emb)
        scores.append((i, score))
    scores.sort(key=lambda x: x[1], reverse=True)
    return scores[:top_k]

La find_relevant función clasifica todos los documentos por similitud y devuelve las coincidencias principales. Este enfoque funciona bien para colecciones pequeñas. Para conjuntos de datos más grandes, considere la posibilidad de usar una base de datos vectorial dedicada.

Generar respuestas fundamentadas

Cargando un modelo de chat y combinando los documentos recuperados con la pregunta del usuario en un mensaje del sistema. El modelo de chat usa el contexto proporcionado para generar una respuesta que se basa en los documentos.

Agregue el código siguiente a la main() función después de la sección de inserción:

    # Load the chat model
    chat_model = manager.catalog.get_model("qwen2.5-0.5b")
    chat_model.download(
        lambda p: print(f"\rDownloading chat model: {p:.1f}%", end="", flush=True)
    )
    print()
    chat_model.load()
    chat_client = chat_model.get_chat_client()

    print("\nModels loaded. Ready for questions.")
    print("\nThe knowledge base contains information about:")
    print("  - Foundry Local features and architecture")
    print("  - Supported programming languages")
    print("  - Embedding models and vector search")
    print("  - ONNX Runtime inference")
    print("  - The model catalog")
    print("  - RAG and chat completions")
    print("\nExample questions:")
    print('  "What programming languages does the SDK support?"')
    print('  "How does Foundry Local run models?"')
    print('  "What is retrieval-augmented generation?"')
    print('\nType "quit" to exit.\n')

    # Interactive query loop
    while True:
        query = input("Question: ").strip()
        if not query or query.lower() == "quit":
            break

        # Embed the query
        query_response = embedding_client.generate_embedding(query)
        query_embedding = query_response.data[0].embedding

        # Retrieve the most relevant documents
        results = find_relevant(query_embedding, doc_embeddings, top_k=2)
        context = "\n".join(f"- {documents[i]}" for i, _ in results)

        # Build the prompt with retrieved context
        messages = [
            {
                "role": "system",
                "content": (
                    "Answer the user's question using only the provided context. "
                    "If the context doesn't contain enough information, say so.\n\n"
                    f"Context:\n{context}"
                ),
            },
            {"role": "user", "content": query},
        ]

        # Stream the response
        print("Answer: ", end="", flush=True)
        for chunk in chat_client.complete_streaming_chat(messages):
            content = chunk.choices[0].delta.content
            if content:
                print(content, end="", flush=True)
        print("\n")

    # Clean up
    embedding_model.unload()
    chat_model.unload()
    print("Models unloaded. Done!")


if __name__ == "__main__":
    main()

La solicitud del sistema indica al modelo que responda con solo el contexto recuperado. El mensaje del sistema hace que las respuestas se basen en tus documentos y reduce las respuestas incorrectas. La salida de streaming imprime cada token a medida que se genera, lo que hace que la respuesta se sienta interactiva.

Código completo

Esta es la aplicación completa que combina todos los pasos:

import math
from foundry_local_sdk import Configuration, FoundryLocalManager

# Knowledge base
documents = [
    "Foundry Local runs AI models directly on your device without cloud connectivity.",
    "The Foundry Local SDK supports Python, C#, JavaScript, and Rust.",
    "Embedding models convert text into numerical vectors for similarity search.",
    "Foundry Local uses ONNX Runtime for efficient model inference on CPUs and GPUs.",
    "The model catalog provides pre-optimized models that you can download and run locally.",
    "Retrieval-augmented generation grounds model responses in your own data.",
    "Vector similarity search finds documents that are semantically close to a query.",
    "Chat completions generate natural language responses from a prompt and context.",
]


def cosine_similarity(a, b):
    """Compute cosine similarity between two vectors."""
    dot = sum(x * y for x, y in zip(a, b))
    norm_a = math.sqrt(sum(x * x for x in a))
    norm_b = math.sqrt(sum(x * x for x in b))
    return dot / (norm_a * norm_b) if norm_a and norm_b else 0.0


def find_relevant(query_embedding, doc_embeddings, top_k=2):
    """Return the indices and scores of the top-k most similar documents."""
    scores = []
    for i, doc_emb in enumerate(doc_embeddings):
        score = cosine_similarity(query_embedding, doc_emb)
        scores.append((i, score))
    scores.sort(key=lambda x: x[1], reverse=True)
    return scores[:top_k]


def main():
    # Initialize the SDK
    config = Configuration(app_name="foundry_local_rag")
    FoundryLocalManager.initialize(config)
    manager = FoundryLocalManager.instance

    # Load the embedding model
    embedding_model = manager.catalog.get_model("qwen3-embedding-0.6b")
    embedding_model.download(
        lambda p: print(f"\rDownloading embedding model: {p:.1f}%", end="", flush=True)
    )
    print()
    embedding_model.load()
    embedding_client = embedding_model.get_embedding_client()

    # Embed all documents
    response = embedding_client.generate_embeddings(documents)
    doc_embeddings = [item.embedding for item in response.data]
    print(f"Indexed {len(doc_embeddings)} documents.")

    # Load the chat model
    chat_model = manager.catalog.get_model("qwen2.5-0.5b")
    chat_model.download(
        lambda p: print(f"\rDownloading chat model: {p:.1f}%", end="", flush=True)
    )
    print()
    chat_model.load()
    chat_client = chat_model.get_chat_client()

    print("\nModels loaded. Ready for questions.")
    print("\nThe knowledge base contains information about:")
    print("  - Foundry Local features and architecture")
    print("  - Supported programming languages")
    print("  - Embedding models and vector search")
    print("  - ONNX Runtime inference")
    print("  - The model catalog")
    print("  - RAG and chat completions")
    print("\nExample questions:")
    print('  "What programming languages does the SDK support?"')
    print('  "How does Foundry Local run models?"')
    print('  "What is retrieval-augmented generation?"')
    print('\nType "quit" to exit.\n')

    # Interactive query loop
    while True:
        query = input("Question: ").strip()
        if not query or query.lower() == "quit":
            break

        # Embed the query
        query_response = embedding_client.generate_embedding(query)
        query_embedding = query_response.data[0].embedding

        # Retrieve the most relevant documents
        results = find_relevant(query_embedding, doc_embeddings, top_k=2)
        context = "\n".join(f"- {documents[i]}" for i, _ in results)

        # Build the prompt with retrieved context
        messages = [
            {
                "role": "system",
                "content": (
                    "Answer the user's question using only the provided context. "
                    "If the context doesn't contain enough information, say so.\n\n"
                    f"Context:\n{context}"
                ),
            },
            {"role": "user", "content": query},
        ]

        # Stream the response
        print("Answer: ", end="", flush=True)
        for chunk in chat_client.complete_streaming_chat(messages):
            content = chunk.choices[0].delta.content
            if content:
                print(content, end="", flush=True)
        print("\n")

    # Clean up
    embedding_model.unload()
    chat_model.unload()
    print("Models unloaded. Done!")


if __name__ == "__main__":
    main()

Ejecute la aplicación:

python main.py

Verá una salida similar a la siguiente:

Downloading embedding model: 100.0%
Indexed 8 documents.
Downloading chat model: 100.0%

Models loaded. Ready for questions.

The knowledge base contains information about:
  - Foundry Local features and architecture
  - Supported programming languages
  - Embedding models and vector search
  - ONNX Runtime inference
  - The model catalog
  - RAG and chat completions

Example questions:
  "What programming languages does the SDK support?"
  "How does Foundry Local run models?"
  "What is retrieval-augmented generation?"

Type "quit" to exit.

Question: What programming languages does the SDK support?
Answer: The Foundry Local SDK supports Python, C#, JavaScript, and Rust.

Question: quit
Models unloaded. Done!

Limpieza de recursos

Los parámetros de ponderación del modelo se quedan almacenados en la memoria caché local después de descargar un modelo. La próxima vez que ejecute la aplicación, se omite el paso de descarga y los modelos se cargan más rápido. No se necesita ninguna limpieza adicional a menos que quiera reclamar espacio en disco.

Contenido relacionado

• Generación de incrustaciones de texto con Foundry Local
• Tutorial: Creación de un asistente de chat de varios turnos
• Utilice la API de finalizaciones de chat nativas con Foundry Local
• Referencia del SDK local de Foundry