Membina Perancang Tugas AI Tempatan dengan ClientAI dan Ollama

Dalam tutorial ini, kami akan membina perancang tugas dikuasakan AI menggunakan ClientAI dan Ollama. Perancang kami akan memecahkan matlamat kepada tugas yang boleh diambil tindakan, mencipta garis masa yang realistik dan mengurus sumber — semua ini dijalankan dalam mesin anda sendiri.

Perancang tugas kami akan mampu:

• Memecahkan matlamat kepada tugasan khusus yang boleh diambil tindakan
• Membuat garis masa yang realistik dengan pengendalian ralat
• Mengurus dan memperuntukkan sumber dengan berkesan
• Menyediakan pelan berstruktur dan berformat

Untuk dokumen ClientAI lihat di sini dan untuk Github Repo, di sini.

Sediakan Persekitaran Kita

Pertama, buat direktori baharu untuk projek anda:

mkdir local_task_planner
cd local_task_planner

Pasang ClientAI dengan sokongan Ollama:

pip install clientai[ollama]

Pastikan anda telah memasang Ollama pada sistem anda. Anda boleh mendapatkannya dari tapak web Ollama.

Buat fail Python utama kami:

touch task_planner.py

Mari mulakan dengan import teras kami:

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

Setiap komponen memainkan peranan penting:

• masa tarikh: Membantu kami mengurus garis masa dan penjadualan tugas
• ClientAI: Menyediakan rangka kerja AI kami
• OllamaManager: Mengurus model AI tempatan kami
• Pelbagai modul utiliti untuk petunjuk jenis dan pengelogan

Membina Teras Perancang Tugas

Pertama, mari buat kelas TaskPlanner kami yang akan mengurus interaksi AI:

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

Kelas ini berfungsi sebagai asas kami. Ia menguruskan kitaran hayat pelayan Ollama, mencipta dan mengkonfigurasi klien AI kami dan menyediakan ejen perancangan kami dengan keupayaan khusus.

Mencipta Alat Perancangan Kami

Sekarang mari kita bina alat yang akan digunakan oleh AI kita. Pertama, pengesah garis masa:

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

Pengesah ini menukar anggaran masa kepada hari bekerja, mengendalikan input yang tidak sah dengan anggun, mencipta penjadualan berurutan yang realistik dan menyediakan pengelogan terperinci untuk penyahpepijatan.

Seterusnya, mari buat pemformat pelan kami:

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

Di sini kami ingin mencipta output yang konsisten dan boleh dibaca dengan penomboran tugas yang betul dan garis masa yang teratur.

Membina Antara Muka

Mari kita cipta antara muka mesra pengguna untuk perancang kami:

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

Antara muka kami menyediakan:

• Kosongkan arahan pengguna
• Penjanaan pelan masa nyata dengan penstriman
• Pengendalian ralat yang betul
• Pengurusan penutupan bersih

Contoh Penggunaan

Berikut ialah perkara yang anda akan lihat apabila anda menjalankan perancang:

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

Penambahbaikan Masa Depan

Pertimbangkan peningkatan ini untuk perancang tugas anda sendiri:

• Tambahkan penjejakan pergantungan antara tugas
• Sertakan pengiraan kos untuk sumber
• Simpan rancangan pada fail atau alatan pengurusan projek
• Jejak kemajuan berbanding pelan asal
• Tambahkan pengesahan untuk ketersediaan sumber
• Laksanakan penjadualan tugas selari
• Tambah sokongan untuk tugasan berulang
• Sertakan tahap keutamaan untuk tugasan

Untuk melihat lebih lanjut tentang ClientAI, pergi ke dokumen.

Berhubung Dengan Saya

Jika anda mempunyai sebarang soalan tentang tutorial ini atau ingin berkongsi peningkatan anda pada perancang tugas, sila hubungi:

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

Atas ialah kandungan terperinci Membina Perancang Tugas AI Tempatan dengan ClientAI dan Ollama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!