Praktische Hinweise: Erstellung autonomer KI-Agenten lokal – Ein Schritt-für-Schritt-Leitfaden
Ausführliche Anleitung zu den Praktischen Hinweisen: Erstellung autonomer KI-Agenten lokal – Ein Schritt-für-Schritt-Leitfaden mit Verträgen, Überprüfungen sowie Code-Blöcken für Teams, die dieses Muster einsetzen.
Die folgenden Notizen skizzieren einen praktischen Ansatz zu dem Thema „Erstellung autonomer KI-Agenten lokal: Ein Schritt-für-Schritt-Leitfaden für Systeme mit 16 GB RAM“. Der Fokus liegt auf Verträgen, Überprüfungen sowie Code-Platzhaltern statt auf motivierenden Formulierungen.
Das Versprechen und die Herausforderungen
Während der Bearbeitung dieser Phase sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems überprüfen können. Erstellen Sie nach aufwändigen Schritten Checkpoints. Beim Wiederaufnehmen des Vorgangs sollte derselbe LLM-Aufruf nicht erneut abgerechnet werden, wenn ein Betreiber einen späteren Schritt wiederholt.
Teil 1: Die Wahl Ihrer Waffe – Das Dilemma bei der Modellauswahl – Bewertung lokaler Modelle für Token-Generierung und agierende Effizienz
Wenn Sie den ersten Schritt „Die Wahl“ durchgehen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholte Versuche, menschliche Überprüfungen und die Handhabung fehlerhafter Nachrichten gehören zum Produkt selbst, nicht zu späteren Optimierungen. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
Die Konkurrenten: Ein direkter Vergleich
Beim Arbeiten an der Phase „The Contenders A Head-to-Head“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Legen Sie nach teuren Schritten Zwischenkontrollpunkte an. Das System sollte bei einer Neuprobe eines späteren Knotens nicht erneut die gleiche LLM-Aufrufgebühr berechnen.
Qwen3.5:4b — Der Geschwindigkeitsrekordhalter
Beim Arbeiten an der Qwen3 5 4b-Phase sollten Sie zunächst einen Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Erstellen Sie Kontrollpunkte nach aufwändigen Schritten. Das Wiederaufnehmen des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf veranlassen, wenn ein Operator einen späteren Knoten erneut versucht.
Llama3.1:latest (8B) — Der zuverlässige Allrounder
Beim Arbeiten mit der neuesten 8B-Version von Llama3 1 sollte man zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgszeichen sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten pro Token oder Abfrage neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo in gemeinsame Umgebungen wechselt. Erstellen Sie nach aufwändigen Schritten einen Checkpoint. Die Wiederaufnahme des Vorgangs sollte keine erneuten Gebühren für denselben LLM-Aufruf verursachen, wenn ein Operator einen späteren Knoten erneut ausführt. Beim Arbeiten mit der neuesten 8B-Version von Llama3 1 sollte man zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgszeichen sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Gemma4:12b-it-q4_K_M – Die Leistungsmaschine für logisches Denken
Die Reasoning-Ebene von Gemma4 12b-it-q4KM funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein erfolgreiches Beispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor großen, komplexen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen und nicht auf ein verworrenes Ablaufverfahren. Legen Sie Budgets für Tokens pro Zug und pro Sitzung fest. Agierende Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
Qwen3.5:9b-q4_K_M – Die ideale Wahl
The Qwen3 5 9b-q4KM: Diese Phase funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie einen erfolgreichen Fall, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Arbeiten ab. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Arbeit.
Vergleichende Modellanalyse
Die Phase der vergleichenden Modellanalyse funktioniert am besten, wenn sie als messbare Größe betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein optimales Transkript, einen Fehlerfall sowie die Notizen zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von Demoumgebungen auf gemeinsam genutzte Umgebungen wechselt. Legen Sie Budgets für Tokens pro Zugriff und pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demos zu unerwarteten Rechnungen werden.
Fazit
Die The Verdict-Ebene funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie einen erfolgreichen Fall, einen Fehlerfall sowie die Rollback-Anmerkung, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne das Durchlesen des gesamten Graphen überprüfen können. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung.
Teil 2: Hardware-Vorbereitung und Einrichtung der lokalen Inferenz
Die Phase der Hardware-Vorbereitung in Teil 2 funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein erfolgreiches Szenario, einen Fehlerfall sowie die Notizen zur Rücksetzung. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf und den Wiederherstellungsprozess. Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Halten Sie den Zustand der Graphen einfach und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Ausführung.
Schritt 1: Installieren Sie Ollama – Ihren lokalen Inferenzmotor
Die Installierungsphase von Ollama in Schritt 1 funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein erfolgreiches Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen und nicht auf ein verworrenes Ablaufschema. Fixieren Sie den Interpreter sowie das Abhängigkeitslockfile, bevor Sie mit Schleifen arbeiten. Unterschiede zwischen Laptop und CI sind die häufigste Ursache für stillschweigende Ausfälle bei API-Demos.
Linux-Installation
Die Linux-Installationsschicht funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie ein perfektes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Schicht als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Halten Sie den Zustand der Graphen einfach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen des Prozesses.
curl -fsSL https://ollama.com/install.sh | sh
macOS-Installation
Die macOS-Installationsschicht funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Halten Sie den Zustand der Diagramme einfach und typisiert – verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen des Ablaufs. Die macOS-Installationsschicht funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
curl -fsSL https://ollama.com/install.sh | sh
Windows-Installation
Zur Windows-Installationsphase sollten die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Setzen Sie menschliche Freigabe bei Schritten ein, die Geld ausgeben oder Produktionsdaten ändern. Kompilierzeitbezogene Verbindungen bedeuten noch nicht vollständige Geschäftsabläufe.
irm https://ollama.com/install.ps1 | iex
Installation überprüfen
Zur Phase „Installation überprüfen“ sollten die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingabedaten und den validierten Ausgabedaten. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Setzen Sie menschliche Freigabe bei Schritten ein, die Geld ausgeben oder Produktionsdaten ändern. Eine Kompilierzeitkonfiguration bedeutet nicht automatisch Geschäftsabschluss.
ollama --version
ollama version is 0.5.x
Schritt 2: Ihr Modell herunterladen
Für den Schritt „Pull Your Stage“ sollten Sie die Eingaben, den Verantwortlichen für diesen Schritt sowie die Abbruchkriterien vor der Codeänderung definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung übergeht. Wählen Sie bei dem nächsten Schritt, der eine Codeänderung oder einen Toolaufruf beinhaltet, strukturierte Ausgaben mit Schema-Validierung statt freier Prosa. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallplan. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
# For the winner
ollama pull qwen3.5:9b-q4_K_M
# For speed
ollama pull qwen3.5:4b
# For reasoning
ollama pull gemma4:e4b-q4_K_M
Schritt 3: Starten Sie den Ollama-Server
Beim Bearbeiten des Schritts „Starten“ sollten Sie zunächst eine Checkliste erstellen: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Wählen Sie lieber kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen und nicht auf ein verworrenes Ablaufschema. Protokollieren Sie bei jedem Aufruf die Anfrage-ID, die Modell-ID sowie die Latenzzeit. Ohne diese Aufzeichnungen wirken gelegentliche Fehler des Anbieters wie Programmierfehler.
ollama serve
Schritt 4: Testen Sie Ihr Modell
Wenn Sie die Phase „Schritt 4: Testen“ durchführen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
ollama run qwen3.5:9b-q4_K_M "Hello, introduce yourself briefly."
Teil 3: Einrichten von CrewAI – Das Orchestrierungsframework
Beim Bearbeiten des Abschnitts „Einstellungen“ in Teil 3 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in gemeinsam genutzte Umgebungen übergeht. Legen Sie nach aufwändigen Schritten einen Kontrollpunkt an. Das Wiederaufnehmen des Prozesses sollte keine erneuten Gebühren für denselben LLM-Aufruf verursachen, wenn ein Operator einen späteren Knoten erneut versucht. Beim Bearbeiten des Abschnitts „Einstellungen“ in Teil 3 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Systemanforderungen
Die Phase der Systemanforderungen funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie ein optimales Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen, komplexen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Halten Sie den Zustand der Graphen einfach und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Fehlern bei Unterbrechungen.
Schritt 1: uv installieren (der moderne Python-Paket-Installer)
Die Schritt-1-Installation der UV-Stage funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein erfolgreiches Beispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung. Behandeln Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Fixieren Sie den Interpreter sowie das Abhängigkeitslockfile, bevor Sie die Schleife implementieren. Abweichungen zwischen Laptop und CI sind der häufigste Grund für stille Ausfälle bei API-Demos.
curl -LsSf https://astral.sh/uv/install.sh | sh
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
Schritt 2: CrewAI CLI installieren
Die Phase „Schritt 2: Installieren von CrewAI“ funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs eine erfolgreiche Transkription, einen Fehlerfall sowie die Notizen zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo in gemeinsam genutzte Umgebungen wechselt. Halten Sie den Zustand des Graphen einfach und typisiert – verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung.
uv tool install crewai
Schritt 3: Erstellen Sie Ihr Crew-Projekt
Schritt 3 „Ihre Ebene erstellen“ funktioniert am besten, wenn er als messbare Struktur betrachtet wird. Erfassen Sie eine gelungene Transkription, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne Durchsicht des gesamten Graphen prüfen können. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung.
crewai create crew my_agent_team
cd my_agent_team
my_agent_team/
├── src/
│ └── my_agent_team/
│ ├── __init__.py
│ ├── crew.py
│ ├── agents.py
│ ├── tasks.py
│ └── main.py
├── .env
└── pyproject.toml
Schritt 4: Abhängigkeiten installieren
Die Phase „Schritt 4: Abhängigkeiten installieren“ funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein erfolgreiches Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf und den Notfallweg. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Halten Sie den Zustand der Graphen strukturiert und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen des Ablaufs.
uv pip install -e .
Schritt 5: Weitere Tools installieren
Die Phase „Schritt 5: Zusätzliche Komponenten installieren“ funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein erfolgreiches Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen komplizierten Ablauf. Stellen Sie Tools mit eng definierten Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.
uv pip install crewai-tools langchain-ollama python-pptx
Teil 4: Aufbau Ihres Agententeams
Teil 4 „Ihre Phase aufbauen“ funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie eine gelungene Transkription, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Halten Sie den Zustand der Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Arbeit.
Die Architektur
Die Architekturphase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Halten Sie den Zustand der Graphen flach und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Ausführung. Die Architekturphase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Schritt 1: Die LLM konfigurieren
Zur ersten Schritt – Konfiguration der Phase – sollten Sie die Eingaben, den Verantwortlichen für diesen Schritt sowie die Abbruchkriterien definieren, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Wählen Sie kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Verwenden Sie bei dem nächsten Schritt Code oder einen Toolaufruf strukturierte Ausgaben mit Schema-Validierung statt freier Prosa.
from langchain_ollama import OllamaLLM
def get_llm():
""" Initialize the local LLM for CrewAI."""
return OllamaLLM(
model="qwen3.5:9b-q4_K_M",
base_url="http://localhost:11434",
temperature=0.3, # Lower = more deterministic
top_p=0.9,
)
Schritt 2: Definieren Sie Ihre Agenten
Zur Phase 2 „Definieren Sie Ihre Schritte“ sollten vor der Codeänderung die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien festgelegt werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Setzen Sie menschliche Freigabe bei Schritten ein, die Geld kosten oder Produktionsdaten ändern. Eine Kompilierzeitkonfiguration bedeutet nicht automatisch Geschäftsabschluss.
from crewai import Agent
from crewai_tools import SerperDevTool, FileReadTool
from .llm_config import get_llm
# Initialize tools
search_tool = SerperDevTool() # Requires Serper API key (free tier available)
file_tool = FileReadTool()
def create_coding_agent():
"""Agent specialized in writing and reviewing code."""
return Agent(
role="Senior Software Engineer",
goal="Write clean, efficient, and well-documented code that solves the given problem",
backstory="""You are a senior software engineer with 15 years of experience
across multiple programming languages. You specialize in Python, JavaScript,
and system architecture. You write code that is not only functional but
also maintainable and follows best practices.""",
tools=[file_tool], # Can read existing files
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
def create_research_agent():
"""Agent specialized in deep research and report writing."""
return Agent(
role="Lead Research Analyst",
goal="Conduct thorough research and synthesize findings into comprehensive reports",
backstory="""You are a seasoned research analyst with a PhD in Computer Science.
You have expertise in finding, verifying, and synthesizing information from
multiple sources. Your reports are known for their depth, clarity, and
actionable insights.""",
tools=[search_tool], # Can search the web
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
def create_presentation_agent():
"""Agent specialized in creating PowerPoint presentations."""
return Agent(
role="Senior Presentation Designer",
goal="Transform research findings into compelling, visually-appealing PowerPoint presentations",
backstory="""You are a presentation designer with 10 years of experience
creating executive-level decks for Fortune 500 companies. You know how to
structure information for maximum impact and create slides that tell a
compelling story.""",
tools=[], # We'll handle PPT generation separately
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
Schritt 3: Definieren Sie Ihre Aufgaben
Zur Schritt 3 „Definieren Sie Ihre Phase“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie Zeiten sowie Kosten für Token oder Abfragen zusammen mit den funktionalen Ergebnissen fest. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozesspfad von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Setzen Sie menschliche Freigabe für Schritte ein, die Geld kosten oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung. Zur Schritt 3 „Definieren Sie Ihre Phase“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Kontrollpunkte und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.
from crewai import Task
def create_coding_task(topic, requirements):
"""Task for the coding agent."""
return Task(
description=f"""
Write a Python solution for the following problem:
Topic: {topic}
Requirements: {requirements}
Your response should include:
1. Complete, working Python code
2. Explanation of the approach
3. Time and space complexity analysis
4. Example usage
Make sure the code is production-ready and includes error handling.
""",
expected_output="A complete Python solution with documentation and analysis.",
agent=None, # Will be assigned later
)
def create_research_task(query):
"""Task for the research agent."""
return Task(
description=f"""
Conduct in-depth research on the following topic:
Query: {query}
Your research should cover:
1. Current state of the art
2. Key players and technologies
3. Challenges and limitations
4. Future trends and predictions
5. Actionable recommendations
Cite your sources and provide a well-structured report.
""",
expected_output="A comprehensive research report with citations.",
agent=None, # Will be assigned later
)
def create_presentation_task(research_findings):
"""Task for the presentation agent."""
return Task(
description=f"""
Create a PowerPoint presentation based on the following research:
{research_findings}
The presentation should include:
1. Title slide with a compelling title
2. Executive summary
3. Key findings (3-5 slides)
4. Visual data representation
5. Recommendations
6. Conclusion and next steps
Provide a detailed outline and slide content.
""",
expected_output="A detailed PowerPoint presentation outline with slide content.",
agent=None, # Will be assigned later
)
Schritt 4: Die Crew koordinieren
Beim Bearbeiten von Schritt 4 „Die Crew koordinieren“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Legen Sie nach teuren Schritten Kontrollpunkte an. Das System sollte bei erneuter Ausführung eines späteren Knotens nicht denselben LLM-Aufruf erneut berechnen.
from crewai import Crew, Process
from .agents import (
create_coding_agent,
create_research_agent,
create_presentation_agent
)
from .tasks import (
create_coding_task,
create_research_task,
create_presentation_task
)
def create_crew(topic, query, requirements):
"""Create and configure the multi-agent crew."""
# Initialize agents
coding_agent = create_coding_agent()
research_agent = create_research_agent()
presentation_agent = create_presentation_agent()
# Create tasks
coding_task = create_coding_task(topic, requirements)
research_task = create_research_task(query)
# Assign agents to tasks
coding_task.agent = coding_agent
research_task.agent = research_agent
# The presentation task depends on research findings
# We'll create it dynamically after research is complete
return Crew(
agents=[coding_agent, research_agent, presentation_agent],
tasks=[coding_task, research_task],
process=Process.sequential, # Tasks run in order
verbose=True,
)
def run_crew(topic, query, requirements):
"""Run the multi-agent crew and return results."""
crew = create_crew(topic, query, requirements)
result = crew.kickoff()
return result
Schritt 5: Der Haupt-Eingangspunkt
Beim Arbeiten an Schritt 5, der Hauptphase, sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgszeichen sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Erstellen Sie Kontrollpunkte nach aufwändigen Schritten. Das System sollte bei erneuten Versuchen eines Operators an einem späteren Knoten nicht denselben LLM-Aufruf erneut berechnen.
import os
from .crew import run_crew
def main():
"""Main entry point for the multi-agent system."""
# Define your project
topic = "Building a REST API with FastAPI"
query = "Best practices for FastAPI REST API development in 2026"
requirements = """
- Python 3.11+
- FastAPI framework
- PostgreSQL database
- JWT authentication
- Docker deployment
"""
print("🚀 Starting multi-agent workflow...")
print("=" * 50)
# Run the crew
result = run_crew(topic, query, requirements)
print("\n✅ Workflow complete!")
print("=" * 50)
print("\n📊 Results:")
print(result)
return result
if __name__ == "__main__":
main()
Teil 5: Automatische Erstellung von PowerPoint-Präsentationen
Beim Arbeiten an der Phase „Automatische Erstellung von PowerPoint-Präsentationen“ in Teil 5 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgszeichen sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben.
Schritt 1: Erstellen des PPT-Generators
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.enum.text import PP_ALIGN
from pptx.dml.color import RGBColor
import os
def create_presentation_from_content(content, filename="presentation.pptx"):
"""
Generate a PowerPoint presentation from structured content.
Args:
content: Dictionary with slide titles and content
filename: Output filename
"""
prs = Presentation()
# Set slide dimensions (16:9)
prs.slide_width = Inches(13.333)
prs.slide_height = Inches(7.5)
# Title Slide
title_slide_layout = prs.slide_layouts[0]
slide = prs.slides.add_slide(title_slide_layout)
slide.shapes.title.text = content.get("title", "AI-Generated Presentation")
slide.placeholders[1].text = content.get("subtitle", "Powered by CrewAI + Ollama")
# Content Slides
for slide_data in content.get("slides", []):
bullet_slide_layout = prs.slide_layouts[1]
slide = prs.slides.add_slide(bullet_slide_layout)
# Title
slide.shapes.title.text = slide_data.get("title", "Untitled")
# Content
content_text = slide.placeholders[1]
content_frame = content_text.text_frame
content_frame.clear()
for point in slide_data.get("points", []):
p = content_frame.add_paragraph()
p.text = point
p.level = 0
p.font.size = Pt(18)
# Save
prs.save(filename)
print(f"✅ Presentation saved as: {filename}")
return filename
def generate_ppt_from_research(research_text, topic):
"""
Generate a PPT from research findings using the presentation agent.
"""
from .agents import create_presentation_agent
from .llm_config import get_llm
# Have the presentation agent structure the content
agent = create_presentation_agent()
prompt = f"""
Based on the following research about "{topic}", create a structured
presentation outline with 6-8 slides.
Research:
{research_text[:2000]} # Limit to avoid context overflow
Return a JSON object with the following structure:
{{
"title": "Presentation title",
"subtitle": "Subtitle or tagline",
"slides": [
{{
"title": "Slide title",
"points": ["Point 1", "Point 2", "Point 3"]
}}
]
}}
"""
# Get structured output from the agent
response = agent.llm.invoke(prompt)
# Parse the response (simplified - in production, use proper JSON parsing)
import json
try:
# Extract JSON from response
content = json.loads(response)
except:
# Fallback: create a simple structure
content = {
"title": f"Research on {topic}",
"subtitle": "AI-Generated Presentation",
"slides": [
{"title": "Introduction", "points": ["Overview of research"]},
{"title": "Key Findings", "points": ["Finding 1", "Finding 2"]},
{"title": "Recommendations", "points": ["Recommendation 1"]}
]
}
# Generate the PPT
filename = f"{topic.replace(' ', '_')}_presentation.pptx"
return create_presentation_from_content(content, filename)
Schritt 2: Integration der PPT-Generierung in Crew
from .ppt_generator import generate_ppt_from_research
def run_full_workflow(topic, query, requirements):
"""Run the complete workflow including PPT generation."""
# Step 1: Run the crew (coding + research)
crew_result = run_crew(topic, query, requirements)
# Step 2: Extract research findings (simplified - in production, parse properly)
research_findings = crew_result # This would be the research agent's output
# Step 3: Generate PowerPoint
ppt_file = generate_ppt_from_research(research_findings, topic)
return {
"crew_result": crew_result,
"presentation_file": ppt_file
}
Teil 6: Häufige Fehlerquellen und deren Behebung
Problem 1: „Connection refused“, wenn CrewAI versucht, Ollama zu erreichen
litellm.APIConnectionError: OllamaException - [Errno 111] Connection refused
llm = OllamaLLM(
model="qwen3.5:9b-q4_K_M",
base_url="http://localhost:11434", # Ensure this is correct
)
Problem 2: Das Modell befolgt die Skripte zur Aufrufung von Tools nicht
Problem 3: Fehler wegen zu geringer Speichermenge (OOM)
Problem 4: Der Agent steckt in rekursiven Schleifen fest
Problem 5: Langsame Token-Generierung
Teil 7: Ausführung Ihres ersten Multi-Agent-Workflows
Die vollständige Einrichtung
#!/usr/bin/env python3
"""
Complete Multi-Agent System with Ollama and CrewAI
"""
import os
import sys
from src.my_agent_team.crew import run_full_workflow
def main():
print("""
╔═══════════════════════════════════════════════════════╗
║ 🤖 Multi-Agent AI System - Local Edition ║
║ Powered by Ollama + CrewAI + Qwen3.5:9b ║
╚═══════════════════════════════════════════════════════╝
""")
# Check if Ollama is running
import requests
try:
response = requests.get("http://localhost:11434")
print("✅ Ollama is running!")
except:
print("❌ Ollama is not running. Please start it with: ollama serve")
sys.exit(1)
# Define your project
topic = input("Enter your project topic (e.g., 'Building a REST API with FastAPI'): ")
query = input("Enter your research query (e.g., 'Best practices for FastAPI'): ")
requirements = input("Enter your requirements (e.g., 'Python, PostgreSQL, JWT'): ")
print("\n🚀 Starting multi-agent workflow...")
print("=" * 60)
try:
result = run_full_workflow(topic, query, requirements)
print("\n✅ Workflow complete!")
print("=" * 60)
print(f"\n📄 Presentation saved as: {result['presentation_file']}")
print("\n📊 Crew Results:")
print(result['crew_result'])
except Exception as e:
print(f"\n❌ Error: {e}")
print("\n💡 Troubleshooting tips:")
print("1. Make sure Ollama is running: ollama serve")
print("2. Check if the model is downloaded: ollama list")
print("3. Ensure you have enough memory (close other apps)")
print("4. Check the error message above for specific issues")
if __name__ == "__main__":
main()
Führen Sie es aus!
python run.py