Einen KI-Assistenten erstellen
Entwickeln Sie einen intelligenten virtuellen Assistenten, der Werkzeuge nutzen, Wissensdatenbanken durchsuchen und Aufgaben erledigen kann – weit über einfache Konversation hinaus.
Einführung
Ein KI-Assistent geht weit über einen Chatbot hinaus. Während ein Chatbot nur kommunizieren kann, kann ein Assistent Werkzeuge nutzen, Datenbanken durchsuchen, Aktionen ausführen und sich mit externen Systemen verbinden, um tatsächlich Dinge zu erledigen.
In diesem Leitfaden erstellen Sie einen KI-Assistenten mit Function Calling und Retrieval-Augmented Generation (RAG) – zwei der leistungsstärksten Techniken in der modernen KI-Entwicklung.
Chatbot vs. Assistent
Es ist wichtig, den Unterschied zu verstehen:
- Chatbot — Antwortet auf Nachrichten nur mit seinen Trainingsdaten. Er kann Fragen beantworten und Gespräche führen, aber keine Aktionen ausführen oder auf externe Informationen zugreifen.
- KI-Assistent — Kann Werkzeuge (APIs, Datenbanken, Dateisysteme) nutzen, Echtzeitinformationen abrufen, Funktionen ausführen und im Auftrag des Benutzers handeln.
💡 Stellen Sie es sich so vor
Ein Chatbot ist wie ein Gespräch mit jemandem, der viel weiß, aber in einem leeren Raum sitzt. Ein Assistent ist wie ein Gespräch mit jemandem, der einen Computer, ein Telefon und einen Aktenschrank auf dem Schreibtisch hat – er kann nachschlagen und handeln.
Assistenten-Architektur
Ein gut gestalteter KI-Assistent folgt einer vierstufigen Pipeline:
Anfrage verstehen
Die KI analysiert die Nachricht des Benutzers, um zu verstehen, was benötigt wird. Sie erkennt, ob es sich um eine einfache Frage, eine werkzeugbasierte Aufgabe oder eine mehrstufige Anfrage handelt.
Denken und planen
Die KI entscheidet, welche Werkzeuge oder Datenquellen sie benötigt. Für komplexe Anfragen teilt sie die Aufgabe in kleinere Schritte auf.
Werkzeuge ausführen
Die KI ruft die entsprechenden Funktionen auf – Datenbanksuche, API-Aufruf, Datei lesen – und sammelt die Ergebnisse.
Antwort formulieren
Die KI kombiniert die Werkzeugergebnisse mit ihrem eigenen Wissen, um eine klare, hilfreiche Antwort zu generieren.
Function Calling
Function Calling ermöglicht der KI die Interaktion mit externen Systemen. Sie definieren die verfügbaren Werkzeuge, und die KI entscheidet, wann und wie sie diese nutzt.
import openai, json, os
from dotenv import load_dotenv
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# Define tools the assistant can use
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City name, e.g. Berlin"
}
},
"required": ["location"]
}
}
},
{
"type": "function",
"function": {
"name": "search_database",
"description": "Search the company knowledge base",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search query"
}
},
"required": ["query"]
}
}
}
]
# Implement the actual functions
def get_weather(location):
# In production, call a real weather API
return {"temp": "18°C", "condition": "Sunny", "location": location}
def search_database(query):
# In production, search your actual database
return {"results": [f"Found info about: {query}"]}Nun schreiben wir die Logik, die die Entscheidung der KI verarbeitet, eine Funktion aufzurufen:
def run_assistant(user_message, conversation_history):
conversation_history.append(
{"role": "user", "content": user_message}
)
response = client.chat.completions.create(
model="gpt-4",
messages=conversation_history,
tools=tools,
tool_choice="auto"
)
message = response.choices[0].message
# Check if the model wants to call a function
if message.tool_calls:
conversation_history.append(message)
for tool_call in message.tool_calls:
fn_name = tool_call.function.name
fn_args = json.loads(tool_call.function.arguments)
# Execute the function
if fn_name == "get_weather":
result = get_weather(**fn_args)
elif fn_name == "search_database":
result = search_database(**fn_args)
conversation_history.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
# Get final response with function results
final_response = client.chat.completions.create(
model="gpt-4",
messages=conversation_history
)
return final_response.choices[0].message.content
return message.contentRetrieval-Augmented Generation (RAG)
RAG ermöglicht Ihrem Assistenten, Fragen aus Ihren eigenen Dokumenten zu beantworten, nicht nur aus seinen Trainingsdaten. Es funktioniert, indem relevante Dokumentabschnitte gefunden und in den Kontext der KI eingefügt werden.
from openai import OpenAI
client = OpenAI()
def create_embeddings(texts):
"""Convert text chunks into vector embeddings."""
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
return [item.embedding for item in response.data]
def find_relevant_context(query, documents, doc_embeddings):
"""Find the most relevant documents for a query."""
query_embedding = create_embeddings([query])[0]
# Calculate similarity (cosine similarity)
similarities = []
for i, doc_emb in enumerate(doc_embeddings):
similarity = sum(a * b for a, b in zip(query_embedding, doc_emb))
similarities.append((similarity, documents[i]))
# Return top 3 most relevant documents
similarities.sort(reverse=True)
return [doc for _, doc in similarities[:3]]
def ask_with_context(query, context_docs):
"""Ask the AI with retrieved context."""
context = "\n\n".join(context_docs)
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": f"""Answer based on this context:
{context}
If the answer isn't in the context, say so."""},
{"role": "user", "content": query}
]
)
return response.choices[0].message.content✅ Wahl einer Vektordatenbank
Für produktive RAG-Systeme verwenden Sie eine dedizierte Vektordatenbank wie Pinecone, Weaviate oder ChromaDB anstelle des hier gezeigten einfachen In-Memory-Ansatzes. Diese verarbeiten Millionen von Dokumenten effizient.
Den Assistenten erstellen
Lassen Sie uns Function Calling und RAG zu einem vollständigen Assistenten kombinieren:
class AIAssistant:
def __init__(self, name, system_prompt, tools=None):
self.name = name
self.client = OpenAI()
self.tools = tools or []
self.history = [{"role": "system", "content": system_prompt}]
self.knowledge_base = []
self.kb_embeddings = []
def add_knowledge(self, documents):
"""Add documents to the assistant's knowledge base."""
self.knowledge_base.extend(documents)
self.kb_embeddings = create_embeddings(self.knowledge_base)
def ask(self, question):
"""Process a question with RAG + function calling."""
# Step 1: Retrieve relevant context
context = ""
if self.knowledge_base:
relevant = find_relevant_context(
question, self.knowledge_base, self.kb_embeddings
)
context = "\nRelevant info: " + " | ".join(relevant)
# Step 2: Add context to the question
enhanced_question = question + context
# Step 3: Run through the LLM with tools
return run_assistant(enhanced_question, self.history)
# Usage
assistant = AIAssistant(
name="Company Helper",
system_prompt="You are a helpful company assistant.",
tools=tools
)
assistant.add_knowledge([
"Our office hours are 9 AM to 6 PM CET.",
"We offer free consultations on Tuesdays.",
"Our main product is an AI workspace platform."
])
response = assistant.ask("What are your office hours?")
print(response)Ihren Assistenten testen
Gründliches Testen ist für KI-Assistenten unerlässlich. Testen Sie diese Szenarien:
- Einfache Fragen, die aus der Wissensdatenbank beantwortet werden sollten.
- Fragen, die Werkzeugnutzung erfordern (z.B. Wetterabfragen).
- Mehrstufige Anfragen, die sowohl Wissensabruf als auch Werkzeugausführung benötigen.
- Grenzfälle: Fragen außerhalb des Kompetenzbereichs, mehrdeutige Anfragen und gleichzeitige Werkzeugaufrufe.
Zusammenfassung
Sie haben einen leistungsstarken KI-Assistenten erstellt. Wichtigste Erkenntnisse:
- KI-Assistenten erweitern Chatbots mit Werkzeugen, Wissensdatenbanken und Aktionsfähigkeiten.
- Function Calling lässt die KI entscheiden, wann externe Werkzeuge und APIs genutzt werden.
- RAG ermöglicht dem Assistenten, Fragen aus Ihren eigenen Dokumenten mit hoher Genauigkeit zu beantworten.
- Kombinieren Sie Function Calling und RAG für Assistenten, die sowohl wissen als auch handeln können.