使用 ClientAI 和 Ollama 构建本地 AI 任务规划器

在本教程中，我们将使用 ClientAI 和 Ollama 构建一个人工智能驱动的任务规划器。我们的计划员会将目标分解为可操作的任务，创建现实的时间表并管理资源 - 所有这些都在您自己的机器上运行。

我们的任务规划器将能够：

• 将目标分解为具体的、可操作的任务
• 通过错误处理创建现实的时间表
• 有效管理和分配资源
• 提供结构化、格式化的计划

有关 ClientAI 的文档，请参阅此处；有关 Github Repo，请参阅此处。

设置我们的环境

首先，为您的项目创建一个新目录：

mkdir local_task_planner
cd local_task_planner

在 Ollama 支持下安装 ClientAI：

pip install clientai[ollama]

确保您的系统上安装了 Ollama。您可以从 Ollama 的网站获取。

创建我们的主要 Python 文件：

touch task_planner.py

让我们从核心导入开始：

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

每个组件都起着至关重要的作用：

• 日期时间：帮助我们管理任务时间表和日程安排
• ClientAI：提供我们的人工智能框架
• OllamaManager： 管理我们本地的 AI 模型
• 用于类型提示和日志记录的各种实用模块

构建任务计划核心

首先，让我们创建用于管理 AI 交互的 TaskPlanner 类：

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

这个课程是我们的基础。它管理 Ollama 服务器生命周期，创建和配置我们的 AI 客户端，并设置具有特定功能的规划代理。

创建我们的规划工具

现在让我们构建人工智能将使用的工具。首先，时间线验证器：

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

此验证器将时间估计转换为工作日，优雅地处理无效输入，创建现实的顺序调度并提供详细的调试日志记录。

接下来，让我们创建计划格式化程序：

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

在这里，我们希望通过正确的任务编号和有组织的时间线创建一致、可读的输出。

构建界面

让我们为我们的计划者创建一个用户友好的界面：

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

我们的界面提供：

• 清晰的使用说明
• 通过流媒体实时生成计划
• 正确的错误处理
• 干净的关闭管理

用法示例

以下是运行计划程序时您将看到的内容：

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

未来的改进

为您自己的任务规划器考虑这些增强功能：

• 添加任务之间的依赖关系跟踪
• 包括资源成本计算
• 将计划保存到文件或项目管理工具
• 根据原计划跟踪进度
• 添加资源可用性验证
• 实现并行任务调度
• 添加对重复任务的支持
• 包括任务的优先级

要了解有关 ClientAI 的更多信息，请访问文档。

与我联系

如果您对本教程有任何疑问或想分享您对任务计划程序的改进，请随时联系：

• GitHub：igorbenav
• X/Twitter：@igorbenav
• 领英：伊戈尔

以上是使用 ClientAI 和 Ollama 构建本地 AI 任务规划器的详细内容。更多信息请关注PHP中文网其他相关文章！