Erstellen eines lokalen KI-Aufgabenplaners mit ClientAI und Ollama

In diesem Tutorial erstellen wir einen KI-gestützten Aufgabenplaner mit ClientAI und Ollama. Unser Planer unterteilt Ziele in umsetzbare Aufgaben, erstellt realistische Zeitpläne und verwaltet Ressourcen – alles läuft auf Ihrer eigenen Maschine.

Unser Aufgabenplaner kann:

• Ziele in spezifische, umsetzbare Aufgaben aufteilen
• Erstellung realistischer Zeitpläne mit Fehlerbehandlung
• Ressourcen effektiv verwalten und zuweisen
• Bereitstellung strukturierter, formatierter Pläne

Die Dokumente zu ClientAI finden Sie hier und zum Github Repo hier.

Unsere Umgebung einrichten

Erstellen Sie zunächst ein neues Verzeichnis für Ihr Projekt:

mkdir local_task_planner
cd local_task_planner

Installieren Sie ClientAI mit Ollama-Unterstützung:

pip install clientai[ollama]

Stellen Sie sicher, dass Ollama auf Ihrem System installiert ist. Sie können es auf der Website von Ollama erhalten.

Erstellen Sie unsere Haupt-Python-Datei:

touch task_planner.py

Beginnen wir mit unseren Kernimporten:

from datetime import datetime, timedelta
from typing import Dict, List
import logging

from clientai import ClientAI
from clientai.agent import create_agent, tool
from clientai.ollama import OllamaManager

logger = logging.getLogger(__name__)

Jede Komponente spielt eine entscheidende Rolle:

• Datum/Uhrzeit: Hilft uns bei der Verwaltung von Zeitplänen und der Planung von Aufgaben
• ClientAI: Stellt unser KI-Framework bereit
• OllamaManager: Verwaltet unser lokales KI-Modell
• Verschiedene Hilfsmodule für Typhinweise und Protokollierung

Aufbau des Aufgabenplaner-Kerns

Erstellen wir zunächst unsere TaskPlanner-Klasse, die die KI-Interaktion verwaltet:

class TaskPlanner:
    """A local task planning system using Ollama."""

    def __init__(self):
        """Initialize the task planner with Ollama."""
        self.manager = OllamaManager()
        self.client = None
        self.planner = None

    def start(self):
        """Start the Ollama server and initialize the client."""
        self.manager.start()
        self.client = ClientAI("ollama", host="http://localhost:11434")

        self.planner = create_agent(
            client=self.client,
            role="task planner",
            system_prompt="""You are a practical task planner. Break down goals into
            specific, actionable tasks with realistic time estimates and resource needs.
            Use the tools provided to validate timelines and format plans properly.""",
            model="llama3",
            step="think",
            tools=[validate_timeline, format_plan],
            tool_confidence=0.8,
            stream=True,
        )

Dieser Kurs dient als unsere Grundlage. Es verwaltet den Lebenszyklus des Ollama-Servers, erstellt und konfiguriert unseren KI-Client und richtet unseren Planungsagenten mit spezifischen Funktionen ein.

Erstellen unserer Planungstools

Lassen Sie uns nun die Tools erstellen, die unsere KI verwenden wird. Zuerst der Timeline-Validator:

@tool(name="validate_timeline")
def validate_timeline(tasks: Dict[str, int]) -> Dict[str, dict]:
    """
    Validate time estimates and create a realistic timeline.

    Args:
        tasks: Dictionary of task names and estimated hours

    Returns:
        Dictionary with start dates and deadlines
    """
    try:
        current_date = datetime.now()
        timeline = {}
        accumulated_hours = 0

        for task, hours in tasks.items():
            try:
                hours_int = int(float(str(hours)))

                if hours_int <= 0:
                    logger.warning(f"Skipping task {task}: Invalid hours value {hours}")
                    continue

                days_needed = hours_int / 6
                start_date = current_date + timedelta(hours=accumulated_hours)
                end_date = start_date + timedelta(days=days_needed)

                timeline[task] = {
                    "start": start_date.strftime("%Y-%m-%d"),
                    "end": end_date.strftime("%Y-%m-%d"),
                    "hours": hours_int,
                }

                accumulated_hours += hours_int

            except (ValueError, TypeError) as e:
                logger.warning(f"Skipping task {task}: Invalid hours value {hours} - {e}")
                continue

        return timeline
    except Exception as e:
        logger.error(f"Error validating timeline: {str(e)}")
        return {}

Dieser Validator wandelt Zeitschätzungen in Arbeitstage um, verarbeitet ungültige Eingaben ordnungsgemäß, erstellt eine realistische sequentielle Planung und bietet eine detaillierte Protokollierung zum Debuggen.

Als nächstes erstellen wir unseren Planformatierer:

@tool(name="format_plan")
def format_plan(
    tasks: List[str],
    timeline: Dict[str, dict],
    resources: List[str]
) -> str:
    """
    Format the plan in a clear, structured way.

    Args:
        tasks: List of tasks
        timeline: Timeline from validate_timeline
        resources: List of required resources

    Returns:
        Formatted plan as a string
    """
    try:
        plan = "== Project Plan ==\n\n"

        plan += "Tasks and Timeline:\n"
        for i, task in enumerate(tasks, 1):
            if task in timeline:
                t = timeline[task]
                plan += f"\n{i}. {task}\n"
                plan += f"   Start: {t['start']}\n"
                plan += f"   End: {t['end']}\n"
                plan += f"   Estimated Hours: {t['hours']}\n"

        plan += "\nRequired Resources:\n"
        for resource in resources:
            plan += f"- {resource}\n"

        return plan
    except Exception as e:
        logger.error(f"Error formatting plan: {str(e)}")
        return "Error: Unable to format plan"

Hier möchten wir eine konsistente, lesbare Ausgabe mit korrekter Aufgabennummerierung und organisierter Zeitleiste erstellen.

Aufbau der Schnittstelle

Lassen Sie uns eine benutzerfreundliche Oberfläche für unseren Planer erstellen:

def get_plan(self, goal: str) -> str:
    """
    Generate a plan for the given goal.

    Args:
        goal: The goal to plan for

    Returns:
        A formatted plan string
    """
    if not self.planner:
        raise RuntimeError("Planner not initialized. Call start() first.")

    return self.planner.run(goal)

def main():
    planner = TaskPlanner()

    try:
        print("Task Planner (Local AI)")
        print("Enter your goal, and I'll create a practical, timeline-based plan.")
        print("Type 'quit' to exit.")

        planner.start()

        while True:
            print("\n" + "=" * 50 + "\n")
            goal = input("Enter your goal: ")

            if goal.lower() == "quit":
                break

            try:
                plan = planner.get_plan(goal)
                print("\nYour Plan:\n")
                for chunk in plan:
                    print(chunk, end="", flush=True)
            except Exception as e:
                print(f"Error: {str(e)}")

    finally:
        planner.stop()

if __name__ == "__main__":
    main()

Unsere Schnittstelle bietet:

• Klare Benutzeranweisungen
• Planerstellung in Echtzeit mit Streaming
• Richtige Fehlerbehandlung
• Sauberes Shutdown-Management

Beispielverwendung

Das sehen Sie, wenn Sie den Planer ausführen:

Task Planner (Local AI)
Enter your goal, and I'll create a practical, timeline-based plan.
Type 'quit' to exit.

==================================================

Enter your goal: Create a personal portfolio website

Your Plan:

== Project Plan ==

Tasks and Timeline:
1. Requirements Analysis and Planning
   Start: 2024-12-08
   End: 2024-12-09
   Estimated Hours: 6

2. Design and Wireframing
   Start: 2024-12-09
   End: 2024-12-11
   Estimated Hours: 12

3. Content Creation
   Start: 2024-12-11
   End: 2024-12-12
   Estimated Hours: 8

4. Development
   Start: 2024-12-12
   End: 2024-12-15
   Estimated Hours: 20

Required Resources:
- Design software (e.g., Figma)
- Text editor or IDE
- Web hosting service
- Version control system

Zukünftige Verbesserungen

Berücksichtigen Sie diese Verbesserungen für Ihren eigenen Aufgabenplaner:

• Abhängigkeitsverfolgung zwischen Aufgaben hinzufügen
• Beziehen Sie Kostenberechnungen für Ressourcen ein
• Speichern Sie Pläne in Dateien oder Projektmanagement-Tools
• Verfolgen Sie den Fortschritt im Vergleich zum ursprünglichen Plan
• Validierung für Ressourcenverfügbarkeit hinzufügen
• Implementieren Sie eine parallele Aufgabenplanung
• Unterstützung für wiederkehrende Aufgaben hinzufügen
• Geben Sie Prioritätsstufen für Aufgaben ein

Um mehr über ClientAI zu erfahren, gehen Sie zu den Dokumenten.

Verbinde dich mit mir

Wenn Sie Fragen zu diesem Tutorial haben oder Ihre Verbesserungen am Aufgabenplaner mitteilen möchten, wenden Sie sich bitte an:

• GitHub: igorbenav
• X/Twitter: @igorbenav
• LinkedIn: Igor

Das obige ist der detaillierte Inhalt vonErstellen eines lokalen KI-Aufgabenplaners mit ClientAI und Ollama. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!