PlanAI

PlanAI is an innovative system designed for complex task automation through a sophisticated graph-based architecture. It integrates traditional computations and cutting-edge AI technologies to enable versatile and efficient workflow management.

Table of Contents

• Key Features
• Requirements
• Installation
• Usage
• Example: Textbook Q&A Generation
• Example: Deep Research
• Monitoring Dashboard
• Advanced Features
• Documentation
• Contributing
• License

Key Features

• Graph-Based Architecture: Construct dynamic workflows comprising interconnected TaskWorkers for highly customizable automation.
• Hybrid TaskWorkers: Combine conventional computations (e.g., API calls) with powerful LLM-driven operations, leveraging Retrieval-Augmented Generation (RAG) capabilities.
• Type Safety with Pydantic: Ensure data integrity and type consistency across workflows with Pydantic-validated input and output.
• Intelligent Data Routing: Utilize type-aware routing to efficiently manage data flow between nodes, adapting to multiple downstream consumers.
• Input Provenance Tracking: Trace the lineage and origin of each Task as it flows through the workflow, enabling detailed analysis and debugging of complex processes.
• Automatic Prompt Optimization: Improve your LLM prompts using data and AI-driven optimization

Requirements

• Python 3.10+
• Poetry (for development)

Installation

You can install PlanAI using pip:

pip install planai

For development, clone the repository and install dependencies:

git clone https://github.com/provos/planai.git
cd planai
poetry install

Usage

PlanAI allows you to create complex, AI-enhanced workflows using a graph-based architecture. Here's a basic example:

from planai import Graph, TaskWorker, Task, LLMTaskWorker, llm_from_config

# Define custom TaskWorkers
class CustomDataProcessor(TaskWorker):
    output_types: List[Type[Task]] = [ProcessedData]

    def consume_work(self, task: RawData):
        processed_data = self.process(task.data)
        self.publish_work(ProcessedData(data=processed_data))

# Define an LLM-powered task
class AIAnalyzer(LLMTaskWorker):
    prompt: str ="Analyze the provided data and derive insights"
    llm_input_type: Type[Task] = ProcessedData
    output_types: List[Type[Task]] = [AnalysisResult]


# Create and run the workflow
graph = Graph(name="Data Analysis Workflow")
data_processor = CustomDataProcessor()
ai_analyzer = AIAnalyzer(
   llm=llm_from_config(provider="openai", model_name="gpt-4"))

graph.add_workers(data_processor, ai_analyzer)
graph.set_dependency(data_processor, ai_analyzer)

initial_data = RawData(data="Some raw data")
graph.run(initial_tasks=[(data_processor, initial_data)])

Example: Textbook Q&A Generation

PlanAI has been used to create a system for generating high-quality question and answer pairs from textbook content. This example demonstrates PlanAI's capability to manage complex, multi-step workflows involving AI-powered text processing and content generation. The application processes textbook content through a series of steps including text cleaning, relevance filtering, question generation and evaluation, and answer generation and selection. For a detailed walkthrough of this example, including code and explanation, please see the examples/textbook directory. The resulting dataset, generated from "World History Since 1500: An Open and Free Textbook," is available in our World History 1500 Q&A repository, showcasing the practical application of PlanAI in educational content processing and dataset creation.

Example: Deep Research

A Deep Research tech demo built on top of PlanAI that allows in-depth research using public web sources. It can run locally using Ollama leading to better privacy than cloud services.

To try DeepSearch, save the following configuration as docker-compose.yml and run docker-compose up:

services:
  deepsearch:
    image: nielsprovos/deepsearch-container:latest
    ports:
      - "3000:3000"
      - "5050:5050"
      - "8080:8080"
    extra_hosts:
      - "host.docker.internal:host-gateway"

Once started, open http://localhost:3000 in your browser.

Monitoring Dashboard

PlanAI includes a built-in web-based monitoring dashboard that provides real-time insights into your graph execution. This feature can be enabled by setting run_dashboard=True when calling the graph.run() method.

Key features of the monitoring dashboard:

• Real-time Updates: The dashboard uses server-sent events (SSE) to provide live updates on task statuses without requiring page refreshes.
• Task Categories: Tasks are organized into three categories: Queued, Active, and Completed, allowing for easy tracking of workflow progress.
• Detailed Task Information: Each task displays its ID, type, and assigned worker. Users can click on a task to view additional details such as provenance and input provenance.

To enable the dashboard:

graph.run(initial_tasks, run_dashboard=True)

When enabled, the dashboard will be accessible at http://localhost:5000 by default. The application will continue running until manually terminated, allowing for ongoing monitoring of long-running workflows.

Note: Enabling the dashboard will block the main thread, so it's recommended for development and debugging purposes. For production use, consider implementing a separate monitoring solution.

Advanced Features

PlanAI supports advanced features like:

• Caching results with CachedTaskWorker
• Joining multiple task results with JoinedTaskWorker
• Integrating with various LLM providers (OpenAI, Ollama, etc.)
• Function calling for supported models
• Automatic Prompt Optimization: Improve your LLMTaskWorker prompts using AI-driven optimization. Learn more

For more detailed examples and advanced usage, please refer to the examples/ directory in the repository.

Documentation

Full documentation for PlanAI is available at https://docs.getplanai.com/

Contributing

We welcome contributions to PlanAI! Please see our Contributing Guide for more details on how to get started.

Licensing

The PlanAI framework is licensed under the Apache License 2.0. See the LICENSE file for the full license text.

Example Applications:

The examples/ directory contains standalone applications that demonstrate the use of the PlanAI framework. These applications have their own independent licenses:

• examples/deepsearch: Licensed under CC BY-NC-SA 4.0 (LICENSE)
• examples/social, examples/textbook and examples/releasenotes: Licensed under Apache License 2.0 (LICENSE)

Understanding the Licensing Structure:

• The PlanAI framework (Apache 2.0) can be used in both commercial and non-commercial applications, can be modified, and can be distributed, providing significant flexibility for developers.
• Example applications are independent implementations that use PlanAI as a dependency.
• Each example application's license applies only to that specific implementation and does not affect the core framework.
• You can create your own applications using PlanAI under any license compatible with Apache 2.0.

For any questions or support, please open an issue on our GitHub issue tracker.