Création d'un planificateur de tâches d'IA local avec ClientAI et Ollama

Dans ce didacticiel, nous allons créer un planificateur de tâches alimenté par l'IA à l'aide de ClientAI et d'Ollama. Notre planificateur décomposera les objectifs en tâches réalisables, créera des délais réalistes et gérera les ressources — tout cela s'exécutant sur votre propre machine.

Notre planificateur de tâches sera capable de :

• Décomposer les objectifs en tâches spécifiques et réalisables
• Créer des délais réalistes avec gestion des erreurs
• Gérer et allouer efficacement les ressources
• Fournir des plans structurés et formatés

Pour les documents de ClientAI, voir ici et pour Github Repo, ici.

Configurer notre environnement

Tout d'abord, créez un nouveau répertoire pour votre projet :

mkdir local_task_planner
cd local_task_planner

Installez ClientAI avec le support d'Ollama :

pip install clientai[ollama]

Assurez-vous qu'Ollama est installé sur votre système. Vous pouvez l'obtenir sur le site Web d'Ollama.

Créez notre fichier Python principal :

touch task_planner.py

Commençons par nos principales importations :

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__)

Chaque composant joue un rôle crucial :

• datetime : Nous aide à gérer les délais et la planification des tâches
• ClientAI : Fournit notre cadre d'IA
• OllamaManager : Gère notre modèle d'IA local
• Divers modules utilitaires pour les astuces de type et la journalisation

Construire le noyau du planificateur de tâches

Tout d'abord, créons notre classe TaskPlanner qui gérera l'interaction avec l'IA :

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,
        )

Ce cours nous sert de base. Il gère le cycle de vie du serveur Ollama, crée et configure notre client IA et configure notre agent de planification avec des capacités spécifiques.

Créer nos outils de planification

Construisons maintenant les outils que notre IA utilisera. Tout d'abord, le validateur de chronologie :

@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 {}

Ce validateur convertit les estimations de temps en jours ouvrables, gère les entrées non valides avec élégance, crée une planification séquentielle réaliste et fournit une journalisation détaillée pour le débogage.

Ensuite, créons notre formateur de plan :

@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"

Ici, nous souhaitons créer un résultat cohérent et lisible avec une numérotation des tâches appropriée et un calendrier organisé.

Construire l'interface

Créons une interface conviviale pour notre agenda :

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()

Notre interface propose :

• Instructions d'utilisation claires
• Génération de forfaits en temps réel avec streaming
• Gestion appropriée des erreurs
• Gestion propre des arrêts

Exemple d'utilisation

Voici ce que vous verrez lorsque vous exécuterez le planificateur :

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

Améliorations futures

Considérez ces améliorations pour votre propre planificateur de tâches :

• Ajouter un suivi des dépendances entre les tâches
• Inclure les calculs de coûts pour les ressources
• Enregistrer les plans dans des fichiers ou dans des outils de gestion de projet
• Suivez les progrès par rapport au plan initial
• Ajouter une validation pour la disponibilité des ressources
• Mettre en œuvre la planification de tâches parallèles
• Ajouter la prise en charge des tâches récurrentes
• Inclure des niveaux de priorité pour les tâches

Pour en savoir plus sur ClientAI, accédez à la documentation.

Connectez-vous avec moi

Si vous avez des questions sur ce didacticiel ou si vous souhaitez partager vos améliorations apportées au planificateur de tâches, n'hésitez pas à nous contacter :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!