Lernprogramm: Erstellen einer RAG-Anwendung

Erstellen Sie eine Retrieval-Augmented Generation (RAG)-Anwendung, die Fragen zu einer Sammlung von Dokumenten vollständig auf Ihrem Gerät beantwortet. RAG kombiniert die einbettungsbasierte Suche mit einem Chatmodell, sodass Antworten auf Ihre eigenen Daten gestützt werden, anstatt sich ausschließlich auf das Schulungswissen des Modells zu verlassen.

In diesem Lernprogramm erfahren Sie, wie Sie:

• Einrichten eines Projekts und Installieren des Foundry Local SDK
• Erstellen einer Wissensdatenbank von Textdokumenten
• Generieren von Einbettungen für die Dokumente
• Suchen nach relevanten Dokumenten nach Ähnlichkeit
• Antworten generieren, die auf dem abgerufenen Kontext basieren
• Bereinigen von Ressourcen

Voraussetzungen

• Ein Windows, macOS oder Linux-Computer mit mindestens 8 GB RAM.
• Python 3.11 oder höher installiert.

Installieren von Paketen

Wenn Sie Windows entwickeln oder versenden, wählen Sie die Registerkarte Windows aus. Das Windows-Paket ist in die Windows ML Laufzeit integriert. Es bietet den gleichen API-Oberflächenbereich mit einer breiteren Hardwarebeschleunigung.

Windows

pip install foundry-local-sdk-winml openai

Plattformübergreifend

pip install foundry-local-sdk openai

Erstellen einer Wissensbasis

Eine RAG-Anwendung benötigt eine Sammlung von Dokumenten zum Durchsuchen. Definieren Sie eine Liste von Textzeichenfolgen, die als Wissensbasis dienen. In einer Produktionsanwendung kann es sich bei der Liste um Absätze aus Dateien, Datenbankdatensätzen oder einer anderen Textquelle handeln.

Erstellen Sie eine Datei namens main.py , und fügen Sie den folgenden Code hinzu:

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

Generieren von Dokumenteinbettungen

Initialisieren Sie das SDK, laden Sie ein Einbettungsmodell, und konvertieren Sie jedes Dokument in einen numerischen Vektor. Diese Vektoren stellen die semantische Bedeutung jedes Dokuments dar und ermöglichen die Ähnlichkeitssuche.

Fügen Sie den folgenden Code hinzu: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.")

Die generate_embeddings Methode akzeptiert eine Liste von Zeichenfolgen und gibt einen Vektor pro Eingabe zurück. Jeder Vektor erfasst die semantische Bedeutung des Texts, sodass ähnliche Dokumente Vektoren erzeugen, die im Einbettungsraum nah zusammen sind.

Suchen nach relevanten Dokumenten

Um Dokumente zu finden, die sich auf eine Abfrage beziehen, vergleichen Sie die Einbettung der Abfrage mit jeder Dokumenteinbettung unter Verwendung der Kosinusähnlichkeit. Die Kosinusähnlichkeit bestimmt das Maß, in dem zwei Vektoren in ihrer Richtung unabhängig von ihrer Größe ähnlich sind. Werte in der Nähe von 1,0 deuten auf eine hohe Ähnlichkeit hin.

Fügen Sie die folgenden Hilfsfunktionen oberhalb von main() in main.py ein.

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]

Die find_relevant Funktion bewertet alle Dokumente nach Ähnlichkeit und gibt die obersten Übereinstimmungen zurück. Dieser Ansatz eignet sich gut für kleine Sammlungen. Berücksichtigen Sie für größere Datasets eine dedizierte Vektordatenbank.

Fundierte Antworten generieren

Laden Sie ein Chatmodell, und kombinieren Sie die abgerufenen Dokumente mit der Frage des Benutzers in einer Systemaufforderung. Das Chatmodell verwendet den bereitgestellten Kontext, um eine Antwort zu generieren, die in Ihren Dokumenten verankert ist.

Fügen Sie der main() Funktion nach dem Einbettungsabschnitt den folgenden Code hinzu:

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

Die Systemaufforderung weist das Modell an, nur den abgerufenen Kontext zu verwenden. Der System Prompt sorgt dafür, dass die Antworten in Ihren Dokumenten gegroundet sind, und reduziert falsche Antworten. Die Streamingausgabe gibt jedes Token aus, sobald es generiert wird, und lässt die Antwort interaktiv wirken.

Vollständiger Code

Hier ist die vollständige Anwendung, die alle Schritte kombiniert:

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

Führen Sie die Anwendung aus:

python main.py

Ihre Ausgabe sieht ähnlich wie diese aus:

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!

Bereinigen von Ressourcen

Die Gewichtungen des Modells verbleiben im lokalen Cache, nachdem Sie ein Modell entladen haben. Wenn Sie die Anwendung das nächste Mal ausführen, wird der Downloadschritt übersprungen, und die Modelle werden schneller geladen. Es ist keine zusätzliche Bereinigung erforderlich, es sei denn, Sie möchten Speicherplatz freigeben.

Verwandte Inhalte

• Generieren von Texteinbettungen mit "Foundry Local"
• Anleitung: Erstellen eines mehrstufigen Chat-Assistenten
• Verwendung der API für native Chat-Vervollständigungen mit Foundry Local
• Foundry Local SDK-Referenz