Kurz: Sestavení aplikace RAG

Vytvořte aplikaci RAG (retrieval-augmented generation), která odpovídá na otázky týkající se kolekce dokumentů zcela na vašem zařízení. RAG kombinuje vyhledávání na základě vnoření s chatovacím modelem, aby odpovědi byly založeny na vašich vlastních datech, spíše než aby se pouze spoléhaly na tréninkové znalosti modelu.

V tomto kurzu se naučíte:

• Nastavení projektu a instalace místní sady SDK Foundry
• Vytvoření znalostní báze textových dokumentů
• Generování embeddingů pro dokumenty
• Hledání relevantních dokumentů podle podobnosti
• Generování odpovědí založených na načteném kontextu
• Vyčištění prostředků

Požadavky

• Počítač s Windows, macOS nebo Linuxem s minimálně 8 GB paměti RAM.
• Python 3.11 nebo novější.

Instalace balíčků

Pokud vyvíjíte nebo odesíláte na platformě Windows, vyberte kartu Windows. Balíček Windows se integruje s modulem runtime Windows ML – poskytuje stejný rozsah rozhraní API s širším rozsahem hardwarové akcelerace.

Windows

pip install foundry-local-sdk-winml openai

Multiplatformní

pip install foundry-local-sdk openai

Vytvoření znalostní báze

Aplikace RAG potřebuje ke vyhledávání kolekci dokumentů. Definujte seznam textových řetězců, které slouží jako znalostní báze. V produkční aplikaci může být seznam odstavce ze souborů, databázových záznamů nebo jakéhokoli jiného textového zdroje.

Vytvořte volaný main.py soubor a přidejte následující kód:

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.",
]

Generování embeddingů dokumentů

Inicializace sady SDK, načtení modelu vkládání a převod každého dokumentu na číselný vektor Tyto vektory představují sémantický význam každého dokumentu a umožňují vyhledávání podobnosti.

Přidejte následující kód do 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.")

Metoda generate_embeddings přijímá seznam řetězců a vrací jeden vektor na vstup. Každý vektor zachycuje sémantický význam textu, takže podobné dokumenty vytvářejí vektory, které jsou blízko sebe v prostoru pro vložení.

Hledání relevantních dokumentů

Pokud chcete najít dokumenty související s dotazem, porovnejte vkládání dotazu s každým vkládáním dokumentů pomocí kosinusové podobnosti. Kosinus podobnost měří, jak blízko jsou dva vektory ve směru bez ohledu na velikost. Hodnoty v blízkosti 1,0 označují vysokou podobnost.

Výše uvedené main() pomocné funkce přidejte do 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]

Funkce find_relevant seřadí všechny dokumenty podle podobnosti a vrátí nejvyšší shody. Tento přístup funguje dobře u malých kolekcí. U větších datových sad zvažte vyhrazenou vektorovou databázi.

Generování podložených odpovědí

Načtěte model chatu a zkombinujte načtené dokumenty s dotazem uživatele v systémové výzvě. Model chatu používá zadaný kontext k vygenerování odpovědi, která je uzemněná ve vašich dokumentech.

Do funkce main() přidejte následující kód za sekci vkládá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()

Výzva systému dává modelu pokyn, aby odpověděl pouze pomocí načteného kontextu. Systémová výzva zajišťuje, že odpovědi vycházejí z vašich dokumentů a snižuje počet nesprávných odpovědí. Výstup streamování vytiskne každý token při vygenerování, takže bude odezva interaktivní.

Kompletní kód

Tady je úplná aplikace, která kombinuje všechny kroky:

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()

Spusťte aplikaci:

python main.py

Zobrazí se výstup podobný následujícímu:

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!

Vyčištění prostředků

Váhy modelu zůstanou v místní mezipaměti po uvolnění modelu. Při příštím spuštění aplikace se krok stahování přeskočí a modely se načtou rychleji. Pokud nechcete uvolnit místo na disku, není potřeba žádné další vyčištění.

Související obsah

• Generování vkládání textu pomocí Foundry Local
• Kurz: Vytvoření pomocníka pro chat s více funkcemi
• Použití rozhraní API pro dokončování nativních chatů s místní službou Foundry
• Referenční informace k sadě SDK Foundry Local