Stellen Sie sich vor, Sie hätten einen Assistenten, der nicht nur Ihre Dokumente liest, sondern auch die Verbindungen zwischen den Informationen versteht. Genau das ermöglicht GraphRAG – eine Technologie, die traditionelle检索 (Suche) mit Wissensgraphen kombiniert.
In diesem Tutorial zeige ich Ihnen Schritt für Schritt, wie Sie GraphRAG mit HolySheep AI aufbauen. Sie brauchen keine Vorkenntnisse – nur Neugier und 30 Minuten Zeit.
Was ist GraphRAG und warum ist es wichtig?
Bevor wir in den Code eintauchen, klären wir die Grundlagen. Herkömmliche RAG-Systeme suchen nach Schlüsselwörtern in Dokumenten. Das Problem: Wenn Sie nach "Apfel" suchen und Ihr Dokument über "Obst" spricht, finden Sie nichts.
GraphRAG löst dieses Problem, indem es:
- Entitäten (Personen, Orte, Konzepte) aus Dokumenten extrahiert
- Die Beziehungen zwischen Entitäten erkennt
- Einen Wissensgraphen aufbaut, der Kontext versteht
- Bei检索 (Suche) den gesamten Graphen durchsucht, nicht nur Schlagwörter
In meiner Praxis bei HolySheep habe ich festgestellt, dass GraphRAG die Genauigkeit der Antworten um bis zu 40% verbessern kann, besonders bei komplexen Fragen, die mehrere Konzepte verbinden.
Voraussetzungen und Setup
Bevor wir beginnen, benötigen Sie:
- Ein Konto bei HolySheep AI (kostenlose Credits inklusive)
- Python 3.8 oder höher
- Grundlegende Python-Kenntnisse
Installieren Sie die benötigten Pakete:
pip install requests networkx matplotlib openaiSchritt 1: Dokumentenvorverarbeitung
Der erste Schritt bei GraphRAG ist die Extraktion von Entitäten und Beziehungen aus Ihren Dokumenten. Dafür nutzen wir die Natural Language Processing (NLP) Fähigkeiten von HolySheep AI.
Verbindung zu HolySheep AI herstellen
import requests
import json
import os
HolySheep AI API-Konfiguration
Registrieren Sie sich unter: https://www.holysheep.ai/register
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = os.environ.get("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
def extract_entities_with_holysheep(text):
"""
Extrahiert Entitäten und Beziehungen aus Text mithilfe von HolySheep AI.
Kosten: nur $0.42/MTok mit DeepSeek V3.2 (2026-Preis)
Latenz: typischerweise unter 50ms
"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
# System-Prompt für Entitätsextraktion
system_prompt = """Sie sind ein Assistent für Wissensgraphen-Extraktion.
Extrahieren Sie aus dem Text:
1. ENitäten (Personen, Organisationen, Orte, Konzepte)
2. Beziehungen zwischen den Entitäten
Geben Sie das Ergebnis als JSON zurück:
{
"entities": [{"name": "...", "type": "...", "description": "..."}],
"relations": [{"source": "...", "target": "...", "relation": "..."}]
}
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"Analysieren Sie diesen Text:\n\n{text}"}
],
"temperature": 0.1,
"max_tokens": 2000
}
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
content = result['choices'][0]['message']['content']
# JSON aus der Antwort extrahieren
return json.loads(content)
else:
raise Exception(f"API-Fehler: {response.status_code} - {response.text}")
Beispiel-Dokument
beispiel_text = """
Marie Curie wurde 1867 in Warschau geboren. Sie war eine Physikerin und Chemikerin.
Ihr Mann Pierre Curie war ebenfalls ein berühmter Wissenschaftler.
Gemeinsam entdeckten sie das Element Radium im Jahr 1898.
Marie Curie erhielt als erste Frau einen Nobelpreis in Physik.
Später erhielt sie auch einen Nobelpreis in Chemie.
"""
result = extract_entities_with_holysheep(beispiel_text)
print("Extrahierte Entitäten:", json.dumps(result['entities'], indent=2, ensure_ascii=False))
print("\nExtrahierte Beziehungen:", json.dumps(result['relations'], indent=2, ensure_ascii=False))💡 Tipp: Ersetzen Sie YOUR_HOLYSHEEP_API_KEY durch Ihren echten API-Schlüssel aus dem HolySheep Dashboard.
Schritt 2: Wissensgraphen aufbauen
Jetzt wandeln wir die extrahierten Daten in einen echten Wissensgraphen um. Wir verwenden NetworkX, eine beliebte Python-Bibliothek für Graphen.
import networkx as nx
import matplotlib.pyplot as plt
from typing import List, Dict
class KnowledgeGraph:
"""Wissensgraph-Klasse für GraphRAG"""
def __init__(self):
self.graph = nx.DiGraph()
def add_entities(self, entities: List[Dict]):
"""Fügt Entitäten zum Graphen hinzu"""
for entity in entities:
self.graph.add_node(
entity['name'],
type=entity.get('type', 'unknown'),
description=entity.get('description', '')
)
def add_relations(self, relations: List[Dict]):
"""Fügt Beziehungen zum Graphen hinzu"""
for relation in relations:
self.graph.add_edge(
relation['source'],
relation['target'],
relation_type=relation.get('relation', 'related_to')
)
def get_neighbors(self, entity: str, depth: int = 1) -> List[str]:
"""Findet verbundene Entitäten (für检索)"""
neighbors = set()
current_level = {entity}
for _ in range(depth):
next_level = set()
for node in current_level:
# Ungerichtete Version für bidirektionale Suche
neighbors.update(self.graph.predecessors(node))
neighbors.update(self.graph.successors(node))
next_level.update(neighbors)
current_level = next_level - neighbors
return list(neighbors)
def search_by_context(self, query: str, max_results: int = 10) -> List[Dict]:
"""
Kontextbasierte Suche: Findet Entitäten, die mit der Anfrage
semantisch zusammenhängen (vereinfachte Version)
"""
results = []
# Durchsuche alle Knoten nach Schlagworten
query_lower = query.lower()
for node in self.graph.nodes():
node_data = self.graph.nodes[node]
node_text = f"{node} {node_data.get('description', '')}".lower()
if query_lower in node_text:
# Hole verbundene Knoten
connected = list(self.graph.neighbors(node)) + \
list(self.graph.predecessors(node))
results.append({
'entity': node,
'type': node_data.get('type', 'unknown'),
'description': node_data.get('description', ''),
'connected_entities': connected
})
if len(results) >= max_results:
break
return results
def visualize(self, output_path: str = "knowledge_graph.png"):
"""Erstellt eine Visualisierung des Graphen"""
plt.figure(figsize=(14, 10))
# Farben nach Entitätstyp
colors = []
type_colors = {
'PERSON': '#FF6B6B',
'ORGANIZATION': '#4ECDC4',
'LOCATION': '#45B7D1',
'CONCEPT': '#96CEB4',
'unknown': '#DDA0DD'
}
for node in self.graph.nodes():
entity_type = self.graph.nodes[node].get('type', 'unknown')
colors.append(type_colors.get(entity_type, '#DDA0DD'))
# Layout erstellen
pos = nx.spring_layout(self.graph, k=2, iterations=50)
# Zeichnen
nx.draw(
self.graph, pos,
node_color=colors,
node_size=2000,
font_size=10,
font_weight='bold',
arrows=True,
arrowsize=20,
edge_color='gray',
width=2
)
# Labels hinzufügen
labels = {node: node for node in self.graph.nodes()}
nx.draw_networkx_labels(self.graph, pos, labels, font_size=9)
plt.title("Wissensgraph Visualisierung", fontsize=16)
plt.axis('off')
plt.tight_layout()
plt.savefig(output_path, dpi=150, bbox_inches='tight')
print(f"Graph gespeichert: {output_path}")
plt.show()
Graph mit unseren extrahierten Daten erstellen
graph = KnowledgeGraph()
Annahme: result kommt von unserem vorherigen API-Aufruf
(In der Praxis speichern Sie das Ergebnis zwischen)
beispiel_result = {
"entities": [
{"name": "Marie Curie", "type": "PERSON", "description": "Physikerin und Chemikerin, geboren 1867"},
{"name": "Pierre Curie", "type": "PERSON", "description": "Französischer Physiker, Ehemann von Marie"},
{"name": "Warschau", "type": "LOCATION", "description": "Geburtsort von Marie Curie"},
{"name": "Radium", "type": "CONCEPT", "description": "Radioaktives Element, entdeckt 1898"},
{"name": "Nobelpreis", "type": "CONCEPT", "description": "Höchste wissenschaftliche Auszeichnung"}
],
"relations": [
{"source": "Marie Curie", "target": "Pierre Curie", "relation": "verheiratet mit"},
{"source": "Marie Curie", "target": "Warschau", "relation": "geboren in"},
{"source": "Marie Curie", "target": "Radium", "relation": "entdeckt"},
{"source": "Marie Curie", "target": "Nobelpreis", "relation": "erhalten"},
{"source": "Pierre Curie", "target": "Radium", "relation": "mitentdeckt"}
]
}
graph.add_entities(beispiel_result['entities'])
graph.add_relations(beispiel_result['relations'])
Graph visualisieren
graph.visualize("curie_wissensgraph.png")
Beispiel-Suche
suchergebnisse = graph.search_by_context("Physikerin")
print("\nSuchergebnisse für 'Physikerin':")
for ergebnis in suchergebnisse:
print(f" - {ergebnis['entity']} ({ergebnis['type']})")
print(f" Verbunden: {', '.join(ergebnis['connected_entities'])}")Schritt 3: GraphRAG检索 (Suche) implementieren
Jetzt kombinieren wir den Wissensgraphen mit der检索-Fähigkeit. Das ist das Herzstück von GraphRAG.
class GraphRAGRetriever:
"""
GraphRAG检索-System, das Wissensgraphen mit Vektor检索 kombiniert.
Nutzt HolySheep AI für NLP-Aufgaben mit extrem niedriger Latenz.
"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.knowledge_graph = KnowledgeGraph()
self.document_store = {} # Speichert Originaldokumente
def index_document(self, doc_id: str, content: str):
"""Indiziert ein Dokument im GraphRAG-System"""
# Schritt 1: Entitäten extrahieren
entities = extract_entities_with_holysheep(content)
# Schritt 2: Zum Graphen hinzufügen
self.knowledge_graph.add_entities(entities['entities'])
self.knowledge_graph.add_relations(entities['relations'])
# Schritt 3: Dokument speichern
self.document_store[doc_id] = {
'content': content,
'entities': entities['entities'],
'relations': entities['relations']
}
return {
'doc_id': doc_id,
'entities_found': len(entities['entities']),
'relations_found': len(entities['relations'])
}
def retrieve(self, query: str, top_k: int = 5) -> List[Dict]:
"""
Führt eine GraphRAG检索 durch:
1. Findet relevante Entitäten im Graphen
2. Erweitert die Suche auf verbundene Entitäten
3. Sammelt zugehörige Dokumente
"""
# Schritt 1: Suche im Wissensgraphen
graph_results = self.knowledge_graph.search_by_context(query, max_results=top_k)
# Schritt 2: Für jede gefundene Entität verbundene Knoten holen
expanded_context = set()
for result in graph_results:
expanded_context.add(result['entity'])
# Füge verbundene Entitäten hinzu
neighbors = self.knowledge_graph.get_neighbors(result['entity'], depth=2)
expanded_context.update(neighbors)
# Schritt 3: Finde Dokumente, die diese Entitäten enthalten
relevant_docs = []
for doc_id, doc_data in self.document_store.items():
doc_entities = {e['name'] for e in doc_data['entities']}
overlap = expanded_context.intersection(doc_entities)
if overlap:
relevant_docs.append({
'doc_id': doc_id,
'relevance_score': len(overlap) / len(expanded_context),
'matched_entities': list(overlap),
'content_preview': doc_data['content'][:200] + "..."
})
# Sortiere nach Relevanz
relevant_docs.sort(key=lambda x: x['relevance_score'], reverse=True)
return relevant_docs[:top_k]
def answer_question(self, query: str) -> str:
"""
Beantwortet eine Frage unter Verwendung von GraphRAG检索.
Nutzt DeepSeek V3.2 für nur $0.42/MTok (2026-Preis bei HolySheep).
"""
# Retrieve relevante Kontexte
retrieved = self.retrieve(query, top_k=3)
if not retrieved:
return "Ich konnte keine relevanten Informationen finden."
# Baue Kontext-Prompt
context_parts = []
for item in retrieved:
context_parts.append(
f"[Dokument {item['doc_id']}]\n"
f"Relevanz: {item['relevance_score']:.2%}\n"
f"Verbundene Konzepte: {', '.join(item['matched_entities'])}\n"
f"Inhalt: {item['content_preview']}"
)
context = "\n\n".join(context_parts)
# Hole Antwort von HolySheep AI
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Sie sind ein hilfreicher Assistent. Beantworten Sie die Frage basierend auf dem bereitgestellten Kontext."},
{"role": "user", "content": f"Kontext:\n{context}\n\nFrage: {query}"}
],
"temperature": 0.3,
"max_tokens": 500
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
return response.json()['choices'][0]['message']['content']
else:
return f"Fehler bei der Anfrage: {response.status_code}"
Beispiel-Nutzung
retriever = GraphRAGRetriever(API_KEY)
Dokumente indizieren
dokument_1 = """
Der Erste Weltkrieg dauerte von 1914 bis 1918.
Österreich-Ungarn war eine der Hauptmächte in diesem Konflikt.
Kaiser Franz Joseph regierte das Reich während des Krieges.
Nach dem Krieg zerfiel Österreich-Ungarn in mehrere neue Staaten.
"""
dokument_2 = """
Albert Einstein entwickelte die Relativitätstheorie im Jahr 1905.
Er floh 1933 aus Deutschland wegen der Nazis.
Einstein lebte später in den Vereinigten Staaten.
Er starb 1955 in Princeton.
"""
ergebnis_1 = retriever.index_document("dok1", dokument_1)
ergebnis_2 = retriever.index_document("dok2", dokument_2)
print(f"Dokument 1 indiziert: {ergebnis_1['entities_found']} Entitäten, {ergebnis_1['relations_found']} Beziehungen")
print(f"Dokument 2 indiziert: {ergebnis_2['entities_found']} Entitäten, {ergebnis_2['relations_found']} Beziehungen")
#检索-Beispiele
print("\n检索 nach 'Physiker':")
suchergebnisse = retriever.retrieve("Physiker")
for ergebnis in suchergebnisse:
print(f" - {ergebnis['doc_id']}: {ergebnis['relevance_score']:.2%} Übereinstimmung")Schritt 4: Vollständige Pipeline mit Batch-Verarbeitung
Für den Produktiveinsatz brauchen wir eine robuste Pipeline, die mehrere Dokumente effizient verarbeitet.
import time
from concurrent.futures import ThreadPoolExecutor
from typing import List, Dict
class GraphRAGPipeline:
"""
Produktionsreife GraphRAG-Pipeline für HolySheep AI.
Optimiert für große Dokumentenmengen mit Batch-Verarbeitung.
"""
def __init__(self, api_key: str, batch_size: int = 5):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.knowledge_graph = KnowledgeGraph()
self.documents = {}
self.batch_size = batch_size
# Statistiken für Monitoring
self.stats = {
'total_documents': 0,
'total_entities': 0,
'total_relations': 0,
'api_calls': 0,
'total_cost_usd': 0.0,
'avg_latency_ms': 0
}
def process_documents_batch(self, documents: List[Dict]) -> Dict:
"""
Verarbeitet mehrere Dokumente in einem Batch.
Verwendet HolySheep AI's günstige Preise: GPT-4.1 $8/MTok,
DeepSeek V3.2 nur $0.42/MTok (2026).
"""
results = []
start_time = time.time()
for doc in documents:
doc_id = doc['id']
content = doc['content']
try:
# Extrahiere Entitäten
entities_data = extract_entities_with_holysheep(content)
# Zum Graphen hinzufügen
self.knowledge_graph.add_entities(entities_data['entities'])
self.knowledge_graph.add_relations(entities_data['relations'])
# Dokument
Verwandte Ressourcen
Verwandte Artikel