Erster KI-Assistent mit LlamaIndex und Azure AI

1.  Installation

pip install llama-index

pip install llama-index-vector-stores-azureaisearch
pip install azure-search-documents
pip install llama-index-embeddings-azure-openai
pip install llama-index-llms-azure-openai

from llama_index.llms.azure_openai import AzureOpenAI
from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext
from llama_index.core.settings import Settings
from llama_index.core.node_parser import SentenceSplitter
from azure.search.documents.indexes import SearchIndexClient
from azure.core.credentials import AzureKeyCredential
from azure.search.documents import SearchClient as LISearchClient 
from llama_index.vector_stores.azureaisearch import AzureAISearchVectorStore
from llama_index.vector_stores.azureaisearch import (
    IndexManagement,
)

2.  Konfiguration und Initialisierung

Zuerst müssen Sie Azure OpenAI konfigurieren, indem Sie Ihren API-Schlüssel, den Endpunkt und die Version festlegen. Dieser Schritt stellt sicher, dass Ihre Anwendung mit den Azure OpenAI-Diensten kommunizieren kann.

# Configuration for Azure OpenAI
api_key = "your_azure_openai_api_key_here"
azure_endpoint = "your_azure_openai_endpoint_here"
api_version="2024-02-15-preview"

# Configuration for Azure Search Service
search_service_api_key = "your_azure_search_service_admin_key_here"
search_service_endpoint= "your_azure_search_service_endpoint_here"
search_creds = AzureKeyCredential(search_service_api_key)

3. Initialisierung der Azure AI-Komponenten

Initialisieren Sie das Sprachmodell und das Einbettungsmodell mit den angegebenen Konfigurationen. Wir verwenden das Modell gpt-35-turbo von AzureOpenAI, um Antworten zu generieren, und text-embedding-ada-002 von AzureOpenAIEmbedding, um Text in numerische Repräsentationen umzuwandeln. Zusätzlich stellen wir unseren zuvor definierten API-Schlüssel, den Azure-Endpunkt und die API-Version bereit.

# Initialize the AzureOpenAI language model
llm = AzureOpenAI(
    model="gpt-35-turbo",
    api_key=api_key,
    azure_endpoint=azure_endpoint,
    api_version=api_version
)

# Initialize the embedding model
embed_model = AzureOpenAIEmbedding(
    model="text-embedding-ada-002",
    api_key=api_key,
    azure_endpoint=azure_endpoint,
    api_version=api_version
)

4. Azure Search Vector Store Setup

Initialisierung eines Clients zum Zugriff auf einen Azure AI-Suchindex: SearchIndexClient wird mit den angegebenen Konfigurationen initialisiert. Dieser Client ermöglicht es Ihnen, Ihren Suchindex zu verwalten und Abfragen durchzuführen.

Initialisierung des Azure Search Vector Store: Richtet den Azure AI Search Vector Store ein und konfiguriert verschiedene Parameter wie Feldschlüssel, Dimensionalität und Sucheinstellungen. index_name ist der Name des Suchindex, mit dem der Client interagiert. Dieser Store ist für die Verwaltung der Speicherung und Abrufung von Vektoreinbettungen in Ihrem Suchindex verantwortlich.

index_client = SearchIndexClient(
    endpoint=search_service_endpoint,
    credential=search_creds
)    

index_name = "llamaindex-vector-demo"

vector_store = AzureAISearchVectorStore(
    search_or_index_client=index_client,
    index_name=index_name,
    index_management=IndexManagement.CREATE_IF_NOT_EXISTS,
    id_field_key="id",
    chunk_field_key="chunk",
    embedding_field_key="embedding",
    embedding_dimensionality=1536,
    metadata_string_field_key="metadata",
    doc_id_field_key="doc_id",
    language_analyzer="en.lucene",
    vector_algorithm_type="exhaustiveKnn",
)

Globale Einstellungen definieren

Bevor wir die Daten laden, definieren wir unsere globalen Einstellungen. LlamaIndex v0.10 führte das Settings-Objekt ein, das nur einmal definiert werden muss und global in unserem nachgelagerten Code verwendet werden kann. Hier konfigurieren wir unser LLM, das auf Aufforderungen und Anfragen reagiert, und unser Einbettungsmodell, das für die Umwandlung von Text in numerische Darstellungen verantwortlich ist.

Settings.llm = llm
Settings.embed_model = embed_model

5. Datenladen und Indizierung

def load_and_index_data(path="./data"):
    docs = SimpleDirectoryReader(input_dir=path, recursive=True).load_data()
    storage_context = StorageContext.from_defaults(vector_store=vector_store)
    index = VectorStoreIndex.from_documents(docs, storage_context=storage_context)
    return index

6. Einrichten der Chat-Engine

Hier rufen wir die Funktion load_and_index_data() auf, die wir gerade implementiert haben, um einen Vektorindex zu erstellen. Anschließend bauen wir eine Chat-Engine aus dem Index und setzen den Chat-Modus auf "condense_question". Dieser Modus generiert eine eigenständige Frage aus dem Gesprächskontext und der letzten Nachricht und fragt dann die Query-Engine mit der generierten Frage ab.

index = load_and_index_data()

chat_engine = index.as_chat_engine(chat_mode="condense_question", verbose=True

Sie können auch andere Chat-Modi ausprobieren:

• Der "context"-Modus ist ein einfacher Chat-Modus, der auf einem Retriever basiert. Bei jeder Interaktion ruft er Text aus dem Index ab, indem er die Eingabe verwendet, und setzt den abgerufenen Text als Kontext im System-Prompt. Schließlich gibt er dem Benutzer eine Antwort.
  
  
• "condense_plus_context" ist ein mehrstufiger Chat-Modus, der auf einem Retriever basiert und den Modus "condense_question" mit dem Kontextmodus kombiniert. Bei jeder Interaktion generiert er eine eigenständige Frage aus dem Gespräch und der neuesten Benutzernachricht. Anschließend baut er einen Kontext für die eigenständige Frage auf und übergibt diesen zusammen mit dem Prompt und der Benutzereingabe an das LLM, um eine Antwort zu generieren.

7. CLI-Interaktion

Zu guter Letzt beginnen wir eine Gesprächsschleife, in der der Benutzer Anfragen eingeben kann und der Chatbot entsprechend antwortet, bis der Benutzer den Vorgang beendet.

while True:
    prompt = input("User: ")
    if prompt == "exit":
        break
    response = chat_engine.chat(prompt)
    print(f"Chatbot: {response}")                    

Sie sollten jetzt in der Lage sein, die Anwendung auszuführen und mit den bereitgestellten Daten zu kommunizieren. Die Anwendung wird weiterhin nach Ihrer Eingabe fragen, bis Sie "exit" eingeben, um den Vorgang zu beenden.

Beispiele

Um unsere Anwendung zu testen, haben wir zwei PDF-Dateien im Datenordner abgelegt, die Informationen über Kaffee und Tee enthalten und die wir von Wikipedia heruntergeladen haben. Nachdem wir die Anwendung gestartet und eine Weile gewartet haben, bis alles eingerichtet war, konnten wir beginnen, Fragen über die CLI-Schnittstelle zu stellen. Hier sind einige Beispiele mit den jeweiligen Antworten des Chatbots. Das LLM verarbeitet auch die Benutzereingaben für Abfragen, wie wir unter "Querying with:"-Ausgabe sehen können.

Beispiel 1:

Beispiel 2:

Hier können wir die Vorteile des condense_question-Modus sehen. Das LLM erinnert sich an die letzte Frage und kombiniert die Eingabe der letzten Frage mit der aktuellen Frage, um eine Abfrage zu generieren und eine Antwort zurückzugeben.

Beispiel 3:

Beispiel 4: