Merge pull request #292 from MervinPraison/develop

Update PraisonAI and praisonaiagents to version 2.0.45 and 0.0.35 res…

Dockerfile

@@ -1,6 +1,6 @@
 FROM python:3.11-slim
 WORKDIR /app
 COPY . .
-RUN pip install flask praisonai==2.0.42 gunicorn markdown
+RUN pip install flask praisonai==2.0.45 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

agents/autonomous-agent.py

@@ -0,0 +1,59 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_environment_feedback():
+    """Simulates environment feedback based on time"""
+    current_time = int(time.time())
+    feedback = "positive" if current_time % 2 == 0 else "negative"
+    print(f"Environment feedback: {feedback}")
+    return feedback
+
+# Create autonomous agent
+autonomous_agent = Agent(
+    name="Autonomous Agent",
+    role="Environment interactor",
+    goal="Interact with environment and learn from feedback",
+    instructions="Take actions based on environment state and adapt from feedback",
+    tools=[get_environment_feedback]
+)
+
+# Create tasks for the autonomous loop
+action_task = Task(
+    name="take_action",
+    description="Analyze environment and take appropriate action",
+    expected_output="Action taken and its rationale",
+    agent=autonomous_agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["process_feedback"],
+    condition={
+        "continue": ["process_feedback"],  # Continue to get feedback
+        "stop": [""]  # Stop when goal is achieved
+    }
+)
+
+feedback_task = Task(
+    name="process_feedback",
+    description="Process environment feedback and adapt strategy",
+    expected_output="Adapted strategy based on feedback",
+    agent=autonomous_agent,
+    next_tasks=["take_action"],
+    context=[action_task]  # Access to previous action for learning
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[autonomous_agent],
+    tasks=[action_task, feedback_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run autonomous workflow
+results = workflow.start()
+
+# Print results
+print("\nAutonomous Agent Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/evaluator-optimiser.py

@@ -0,0 +1,70 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create generator and evaluator agents
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate initial solutions and incorporate feedback",
+    instructions=(
+        "1. Look at the context from previous tasks.\n"
+        "2. If you see that you have already produced 2 points, then add another 2 new points "
+        "   so that the total becomes 10.\n"
+        "3. Otherwise, just produce the first 2 points.\n"
+        "4. Return only the final list of points, with no extra explanation."
+    )
+)
+
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate solutions and provide improvement feedback",
+    instructions=(
+        "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+        "2. If there are 10 or more, respond with 'done'.\n"
+        "3. Otherwise, respond with 'more'.\n"
+        "4. Return only the single word: 'done' or 'more'."
+    )
+)
+
+
+# Create tasks for the feedback loop
+generate_task = Task(
+    name="generate",
+    description="Write 2 points about AI incuding if anything exiting from previous points",
+    expected_output="2 points",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Check if there are 10 points about AI",
+    expected_output="more or done",
+    agent=evaluator,
+    next_tasks=["generate"],
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue to generate
+        "done": [""]  # Exit when optimization complete
+    }
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[generator, evaluator],
+    tasks=[generate_task, evaluate_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run optimization workflow
+results = workflow.start()
+
+# Print results
+print("\nEvaluator-Optimizer Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/orchestrator-workers.py

@@ -0,0 +1,110 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    if current_time % 3 == 0:
+        result = 1
+    elif current_time % 3 == 1:
+        result = 2
+    else:
+        result = 3
+    print(f"Time: {current_time}, Result: {result}")
+    return result
+
+# Create orchestrator and worker agents
+router = Agent(
+    name="Router",
+    role="Task router",
+    goal="Distribute tasks to based on response from get_time_check",
+    tools=[get_time_check]
+)
+
+worker1 = Agent(
+    name="Worker 1",
+    role="Specialized worker",
+    goal="Handle specific subtask type 1",
+)
+
+worker2 = Agent(
+    name="Worker 2",
+    role="Specialized worker",
+    goal="Handle specific subtask type 2",
+)
+
+worker3 = Agent(
+    name="Worker 3",
+    role="Specialized worker",
+    goal="Handle specific subtask type 3",
+)
+
+synthesizer = Agent(
+    name="Synthesizer",
+    role="Result synthesizer",
+    goal="Combine and synthesize worker outputs",
+)
+
+# Create orchestrated workflow tasks
+router_task = Task(
+    name="route_task",
+    description="Analyze input from get_time_check and route to appropriate workers",
+    expected_output="Task routing decision, 1 , 2 or 3",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["worker1_task", "worker2_task", "worker3_task"],
+    condition={
+        "1": ["worker1_task"],
+        "2": ["worker2_task"],
+        "3": ["worker3_task"]
+    }
+)
+
+worker1_task = Task(
+    name="worker1_task",
+    description="Process type 1 operation",
+    expected_output="Worker 1 result",
+    agent=worker1,
+    next_tasks=["synthesize_task"]
+)
+
+worker2_task = Task(
+    name="worker2_task",
+    description="Process type 2 operation",
+    expected_output="Worker 2 result",
+    agent=worker2,
+    next_tasks=["synthesize_task"]
+)
+
+worker3_task = Task(
+    name="worker3_task",
+    description="Process type 3 operation",
+    expected_output="Worker 3 result",
+    agent=worker3,
+    next_tasks=["synthesize_task"]
+)
+
+synthesize_task = Task(
+    name="synthesize_task",
+    description="Synthesize worker results into final output",
+    expected_output="Final synthesized result",
+    agent=synthesizer,
+    context=[worker1_task, worker2_task, worker3_task]
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[router, worker1, worker2, worker3, synthesizer],
+    tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run orchestrated workflow
+results = workflow.start()
+
+# Print results
+print("\nOrchestrator-Workers Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/parallelisation.py

@@ -0,0 +1,95 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from datetime import datetime
+import asyncio
+
+def process_time():
+    """Simulate processing"""
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"Processing at: {current_time}")
+    return f"Processed at {current_time}"
+
+# Create parallel processing agents
+agent1 = Agent(
+    name="Processor 1",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent2 = Agent(
+    name="Processor 2",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent3 = Agent(
+    name="Processor 3",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+aggregator = Agent(
+    name="Aggregator",
+    role="Result aggregator",
+    goal="Collect all the processed time from all tasks"
+)
+
+# Create parallel tasks with memory disabled
+task1 = Task(
+    name="process_1",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent1,
+    is_start=True,
+    async_execution=True
+)
+
+task2 = Task(
+    name="process_2",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent2,
+    is_start=True,
+    async_execution=True
+)
+
+task3 = Task(
+    name="process_3",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent3,
+    is_start=True,
+    async_execution=True
+)
+
+aggregate_task = Task(
+    name="aggregate",
+    description="Collect all the processed time from all tasks",
+    expected_output="Output all the processed time from all tasks and just the time",
+    agent=aggregator,
+    context=[task1, task2, task3]
+)
+
+async def main():
+
+    # Create workflow manager
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, agent3, aggregator],
+        tasks=[task1, task2, task3, aggregate_task],
+        process="workflow"
+    )
+
+    # Run parallel workflow
+    results = await workflow.astart()
+
+    # Print results
+    print("\nParallel Processing Results:")
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"Task {task_id}: {result.raw}")
+
+# Run the async main function
+if __name__ == "__main__":
+    asyncio.run(main())

agents/praisonaiagents/agent/agent.py

@@ -16,7 +16,8 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    error_logs
+    error_logs,
+    adisplay_instruction
 )
 import inspect
 

agents/praisonaiagents/agents/agents.py

@@ -211,6 +211,11 @@ class PraisonAIAgents:
 
         executor_agent = task.agent
 
+        # Ensure tools are available from both task and agent
+        tools = task.tools or []
+        if executor_agent and executor_agent.tools:
+            tools.extend(executor_agent.tools)
+
         task_prompt = f"""
 You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
@@ -267,14 +272,14 @@ Here are the results of previous tasks that might be useful:\n
 
             agent_output = await executor_agent.achat(
                 _get_multimodal_message(task_prompt, task.images),
-                tools=task.tools,
+                tools=tools,
                 output_json=task.output_json,
                 output_pydantic=task.output_pydantic
             )
         else:
             agent_output = await executor_agent.achat(
                 task_prompt,
-                tools=task.tools,
+                tools=tools,
                 output_json=task.output_json,
                 output_pydantic=task.output_pydantic
             )
@@ -380,11 +385,25 @@ Here are the results of previous tasks that might be useful:\n
         )
         
         if self.process == "workflow":
+            # Collect all tasks that should run in parallel
+            parallel_tasks = []
             async for task_id in process.aworkflow():
-                if self.tasks[task_id].async_execution:
-                    await self.arun_task(task_id)
-                else:
-                    self.run_task(task_id)
+                if self.tasks[task_id].async_execution and self.tasks[task_id].is_start:
+                    parallel_tasks.append(task_id)
+                elif parallel_tasks:
+                    # Execute collected parallel tasks
+                    await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                    parallel_tasks = []
+                    # Run the current non-parallel task
+                    if self.tasks[task_id].async_execution:
+                        await self.arun_task(task_id)
+                    else:
+                        self.run_task(task_id)
+            
+            # Execute any remaining parallel tasks
+            if parallel_tasks:
+                await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                
         elif self.process == "sequential":
             async for task_id in process.asequential():
                 if self.tasks[task_id].async_execution:
@@ -596,8 +615,12 @@ Here are the results of previous tasks that might be useful:\n
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        loop = asyncio.get_event_loop()
-                        loop.run_until_complete(task.execute_callback(task_output))
+                        if asyncio.get_event_loop().is_running():
+                            asyncio.create_task(task.execute_callback(task_output))
+                        else:
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(loop)
+                            loop.run_until_complete(task.execute_callback(task_output))
                     except Exception as e:
                         logger.error(f"Error executing memory callback for task {task_id}: {e}")
                         logger.exception(e)
@@ -606,7 +629,12 @@ Here are the results of previous tasks that might be useful:\n
                     if task.callback:
                         try:
                             if asyncio.iscoroutinefunction(task.callback):
-                                loop.run_until_complete(task.callback(task_output))
+                                if asyncio.get_event_loop().is_running():
+                                    asyncio.create_task(task.callback(task_output))
+                                else:
+                                    loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(loop)
+                                    loop.run_until_complete(task.callback(task_output))
                             else:
                                 task.callback(task_output)
                         except Exception as e:

agents/praisonaiagents/process/process.py

@@ -10,14 +10,16 @@ class LoopItems(BaseModel):
     items: List[Any]
 
 class Process:
-    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False):
+    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
         self.tasks = tasks
         self.agents = agents
         self.manager_llm = manager_llm
         self.verbose = verbose
+        self.max_iter = max_iter
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
         for task in self.tasks.values():
             if task.next_tasks:
@@ -41,7 +43,12 @@ class Process:
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
         
-        while current_task and current_task.id not in visited_tasks:
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
             task_id = current_task.id
             logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
             
@@ -111,6 +118,11 @@ Return a JSON object with an 'items' array containing the items to process.
             yield task_id
             visited_tasks.add(task_id)
             
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"
@@ -291,6 +303,7 @@ Provide a JSON with the structure:
 
     def workflow(self):
         """Synchronous version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
         for task in self.tasks.values():
             if task.next_tasks:
@@ -314,7 +327,12 @@ Provide a JSON with the structure:
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
         
-        while current_task and current_task.id not in visited_tasks:
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
             task_id = current_task.id
             logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
             
@@ -378,6 +396,11 @@ Return a JSON object with an 'items' array containing the items to process.
             yield task_id
             visited_tasks.add(task_id)
             
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"

agents/prompt_chaining.py

@@ -1,7 +1,4 @@
-from praisonaiagents.agent import Agent
-from praisonaiagents.task import Task
-from praisonaiagents.agents import PraisonAIAgents
-from typing import List, Dict
+from praisonaiagents import Agent, Task, PraisonAIAgents
 import time
 
 def get_time_check():
@@ -44,7 +41,7 @@ initial_task = Task(
     next_tasks=["advanced_analysis"],  # Next task if condition passes
     condition={
         "even": ["advanced_analysis"],  # If passes, go to advanced analysis
-        "odd": ""  # If fails, exit the chain
+        "odd": "exit"  # If fails, exit the chain
     }
 )
 

agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.32"
+version = "0.0.35"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }

agents/uv.lock

@@ -990,7 +990,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.32"
+version = "0.0.35"
 source = { editable = "." }
 dependencies = [
     { name = "openai" },

cookbooks/general/evaluator-optimiser.py

@@ -0,0 +1,70 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create generator and evaluator agents
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate initial solutions and incorporate feedback",
+    instructions=(
+        "1. Look at the context from previous tasks.\n"
+        "2. If you see that you have already produced 2 points, then add another 2 new points "
+        "   so that the total becomes 10.\n"
+        "3. Otherwise, just produce the first 2 points.\n"
+        "4. Return only the final list of points, with no extra explanation."
+    )
+)
+
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate solutions and provide improvement feedback",
+    instructions=(
+        "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+        "2. If there are 10 or more, respond with 'done'.\n"
+        "3. Otherwise, respond with 'more'.\n"
+        "4. Return only the single word: 'done' or 'more'."
+    )
+)
+
+
+# Create tasks for the feedback loop
+generate_task = Task(
+    name="generate",
+    description="Write 2 points about AI incuding if anything exiting from previous points",
+    expected_output="2 points",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Check if there are 10 points about AI",
+    expected_output="more or done",
+    agent=evaluator,
+    next_tasks=["generate"],
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue to generate
+        "done": [""]  # Exit when optimization complete
+    }
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[generator, evaluator],
+    tasks=[generate_task, evaluate_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run optimization workflow
+results = workflow.start()
+
+# Print results
+print("\nEvaluator-Optimizer Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

cookbooks/general/parallelisation.py

@@ -0,0 +1,95 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from datetime import datetime
+import asyncio
+
+def process_time():
+    """Simulate processing"""
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"Processing at: {current_time}")
+    return f"Processed at {current_time}"
+
+# Create parallel processing agents
+agent1 = Agent(
+    name="Processor 1",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent2 = Agent(
+    name="Processor 2",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent3 = Agent(
+    name="Processor 3",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+aggregator = Agent(
+    name="Aggregator",
+    role="Result aggregator",
+    goal="Collect all the processed time from all tasks"
+)
+
+# Create parallel tasks with memory disabled
+task1 = Task(
+    name="process_1",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent1,
+    is_start=True,
+    async_execution=True
+)
+
+task2 = Task(
+    name="process_2",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent2,
+    is_start=True,
+    async_execution=True
+)
+
+task3 = Task(
+    name="process_3",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent3,
+    is_start=True,
+    async_execution=True
+)
+
+aggregate_task = Task(
+    name="aggregate",
+    description="Collect all the processed time from all tasks",
+    expected_output="Output all the processed time from all tasks and just the time",
+    agent=aggregator,
+    context=[task1, task2, task3]
+)
+
+async def main():
+
+    # Create workflow manager
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, agent3, aggregator],
+        tasks=[task1, task2, task3, aggregate_task],
+        process="workflow"
+    )
+
+    # Run parallel workflow
+    results = await workflow.astart()
+
+    # Print results
+    print("\nParallel Processing Results:")
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"Task {task_id}: {result.raw}")
+
+# Run the async main function
+if __name__ == "__main__":
+    asyncio.run(main())

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.0.42 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.45 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/features/evaluator-optimiser.mdx

@@ -0,0 +1,216 @@
+---
+title: "Agentic Evaluator Optimiser Workflow"
+sidebarTitle: "Evaluator Optimiser"
+description: "Learn how to create AI agents that can generate and optimize solutions through iterative feedback."
+icon: "arrows-rotate"
+---
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `app.py` with the basic setup:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+
+        # Create generator and evaluator agents
+        generator = Agent(
+            name="Generator",
+            role="Solution generator",
+            goal="Generate initial solutions and incorporate feedback",
+            instructions=(
+                "1. Look at the context from previous tasks.\n"
+                "2. If you see that you have already produced 2 points, then add another 2 new points "
+                "   so that the total becomes 10.\n"
+                "3. Otherwise, just produce the first 2 points.\n"
+                "4. Return only the final list of points, with no extra explanation."
+            )
+        )
+
+        evaluator = Agent(
+            name="Evaluator",
+            role="Solution evaluator",
+            goal="Evaluate solutions and provide improvement feedback",
+            instructions=(
+                "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+                "2. If there are 10 or more, respond with 'done'.\n"
+                "3. Otherwise, respond with 'more'.\n"
+                "4. Return only the single word: 'done' or 'more'."
+            )
+        )
+
+        # Create tasks for the feedback loop
+        generate_task = Task(
+            name="generate",
+            description="Write 2 points about AI incuding if anything exiting from previous points",
+            expected_output="2 points",
+            agent=generator,
+            is_start=True,
+            task_type="decision",
+            next_tasks=["evaluate"]
+        )
+
+        evaluate_task = Task(
+            name="evaluate",
+            description="Check if there are 10 points about AI",
+            expected_output="more or done",
+            agent=evaluator,
+            next_tasks=["generate"],
+            context=[generate_task],
+            task_type="decision",
+            condition={
+                "more": ["generate"],  # Continue to generate
+                "done": [""]  # Exit when optimization complete
+            }
+        )
+
+        # Create workflow manager
+        workflow = PraisonAIAgents(
+            agents=[generator, evaluator],
+            tasks=[generate_task, evaluate_task],
+            process="workflow",
+            verbose=True
+        )
+
+        # Run optimization workflow
+        results = workflow.start()
+
+        # Print results
+        print("\nEvaluator-Optimizer Results:")
+        for task_id, result in results["task_results"].items():
+            if result:
+                print(f"Task {task_id}: {result.raw}")
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```bash
+        python app.py
+        ```
+    </Step>
+</Steps>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of Python
+</Note>
+
+## Understanding Evaluator-Optimizer
+
+<Card title="What is Evaluator-Optimizer?" icon="question">
+  Evaluator-Optimizer pattern enables:
+  - Iterative solution generation and refinement
+  - Automated quality evaluation
+  - Feedback-driven optimization
+  - Continuous improvement loops
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Solution Generation" icon="wand-magic-sparkles">
+    Generate solutions based on requirements and feedback.
+  </Card>
+  <Card title="Quality Evaluation" icon="magnifying-glass-chart">
+    Automatically assess solution quality and completeness.
+  </Card>
+  <Card title="Feedback Loop" icon="rotate">
+    Implement iterative improvement through feedback cycles.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and control the optimization process.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create a generator agent
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate and improve solutions",
+    instructions="Step-by-step instructions for generation",
+    verbose=True  # Enable detailed logging
+)
+
+# Create an evaluator agent
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate and provide feedback",
+    instructions="Evaluation criteria and feedback format"
+)
+
+# Create tasks with feedback loop
+generate_task = Task(
+    name="generate",
+    description="Generate solution",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Evaluate solution",
+    agent=evaluator,
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue optimization
+        "done": [""]  # Exit when complete
+    }
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Generation Issues" icon="triangle-exclamation">
+    If generation is not improving:
+    - Review generator instructions
+    - Check feedback integration
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Evaluation Flow" icon="diagram-project">
+    If evaluation cycle is incorrect:
+    - Verify evaluation criteria
+    - Check condition mappings
+    - Review feedback loop connections
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your generator instructions and evaluation criteria are clear and well-defined to achieve the desired optimization outcomes.
+</Note>

docs/features/parallelisation.mdx

@@ -0,0 +1,231 @@
+---
+title: "Agentic Parallelisation"
+description: "Learn how to create AI agents that can execute tasks in parallel for improved performance."
+icon: "arrows-split-up-and-left"
+---
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `app.py` with the basic setup:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        from datetime import datetime
+        import asyncio
+
+        def process_time():
+            """Simulate processing"""
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f"Processing at: {current_time}")
+            return f"Processed at {current_time}"
+
+        # Create parallel processing agents
+        agent1 = Agent(
+            name="Processor 1",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        agent2 = Agent(
+            name="Processor 2",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        agent3 = Agent(
+            name="Processor 3",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        aggregator = Agent(
+            name="Aggregator",
+            role="Result aggregator",
+            goal="Collect all the processed time from all tasks"
+        )
+
+        # Create parallel tasks with memory disabled
+        task1 = Task(
+            name="process_1",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent1,
+            is_start=True,
+            async_execution=True
+        )
+
+        task2 = Task(
+            name="process_2",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent2,
+            is_start=True,
+            async_execution=True
+        )
+
+        task3 = Task(
+            name="process_3",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent3,
+            is_start=True,
+            async_execution=True
+        )
+
+        aggregate_task = Task(
+            name="aggregate",
+            description="Collect all the processed time from all tasks",
+            expected_output="Output all the processed time from all tasks and just the time",
+            agent=aggregator,
+            context=[task1, task2, task3]
+        )
+
+        async def main():
+
+            # Create workflow manager
+            workflow = PraisonAIAgents(
+                agents=[agent1, agent2, agent3, aggregator],
+                tasks=[task1, task2, task3, aggregate_task],
+                process="workflow"
+            )
+
+            # Run parallel workflow
+            results = await workflow.astart()
+
+            # Print results
+            print("\nParallel Processing Results:")
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"Task {task_id}: {result.raw}")
+
+        # Run the async main function
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```bash
+        python app.py
+        ```
+    </Step>
+</Steps>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of Python and async programming
+</Note>
+
+## Understanding Parallelisation
+
+<Card title="What is Parallelisation?" icon="question">
+  Parallelisation enables:
+  - Concurrent execution of multiple tasks
+  - Improved performance through parallel processing
+  - Efficient handling of independent operations
+  - Aggregation of parallel task results
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Parallel Execution" icon="arrows-split-up-and-left">
+    Run multiple tasks simultaneously for improved performance.
+  </Card>
+  <Card title="Async Support" icon="bolt">
+    Built-in support for asynchronous execution.
+  </Card>
+  <Card title="Result Aggregation" icon="layer-group">
+    Combine results from parallel tasks efficiently.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and manage parallel task execution.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create a parallel task
+task = Task(
+    name="parallel_task",
+    description="Task to run in parallel",
+    expected_output="Task result",
+    agent=agent,
+    is_start=True,
+    async_execution=True  # Enable parallel execution
+)
+
+# Create an aggregator task
+aggregator_task = Task(
+    name="aggregate",
+    description="Aggregate results from parallel tasks",
+    expected_output="Combined results",
+    agent=aggregator,
+    context=[task1, task2, task3]  # Reference parallel tasks
+)
+
+# Async workflow execution
+async def run_workflow():
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, aggregator],
+        tasks=[task1, task2, aggregator_task],
+        process="workflow",
+        verbose=True
+    )
+    results = await workflow.astart()
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Execution Issues" icon="triangle-exclamation">
+    If parallel execution fails:
+    - Check async configuration
+    - Verify task independence
+    - Monitor resource usage
+  </Card>
+
+  <Card title="Result Aggregation" icon="diagram-project">
+    If aggregation is incorrect:
+    - Review task outputs
+    - Check context connections
+    - Verify aggregator logic
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your parallel tasks are truly independent and your system has sufficient resources to handle concurrent execution.
+</Note>

docs/mint.json

@@ -91,7 +91,10 @@
         "features/mathagent",
         "features/structured",
         "features/callbacks",
-        "features/agenticrouting"
+        "features/agenticrouting",
+        "features/promptchaining",
+        "features/parallelisation",
+        "features/evaluator-optimiser"
       ]
     },
     {

praisonai.rb

@@ -3,7 +3,7 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.42.tar.gz"
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.45.tar.gz"
     sha256 "1828fb9227d10f991522c3f24f061943a254b667196b40b1a3e4a54a8d30ce32"  # Replace with actual SHA256 checksum
     license "MIT"
   

praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.0.42 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.0.45 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.0.42"
+version = "2.0.45"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.32",
+    "praisonaiagents>=0.0.35",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -84,7 +84,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.0.42"
+version = "2.0.45"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -102,7 +102,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.32"
+praisonaiagents = ">=0.0.35"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

uv.lock

@@ -3060,7 +3060,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.0.42"
+version = "2.0.45"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -3197,7 +3197,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.7" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.7" },
-    { name = "praisonaiagents", specifier = ">=0.0.32" },
+    { name = "praisonaiagents", specifier = ">=0.0.35" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -3250,16 +3250,16 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.32"
+version = "0.0.35"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "openai" },
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/96/b7/3de3e4cff09a2b21f7b8c1555a7f3de8e4a00ff99e63bce778fe9429dc23/praisonaiagents-0.0.32.tar.gz", hash = "sha256:466f43cf9638baac3f1196870c88d02718c9a2f870fe712ee6cbbc8d6c61c6bc", size = 68653 }
+sdist = { url = "https://files.pythonhosted.org/packages/58/2e/f7899ee05c74b0f2ddd237490f361865b85be404f7888c6229e5292a9af4/praisonaiagents-0.0.35.tar.gz", hash = "sha256:23fdda1320f29cdc86162a8a0b8e77bad07ad793a2f08d6d8d7f7729a01f7ab7", size = 69306 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/a6/32e90fe57973b9ebdfcca1ff80fa0142c935517456aef8bdd8ef2118e311/praisonaiagents-0.0.32-py3-none-any.whl", hash = "sha256:f0175e2a8560d1bdc7c06b788d821422d403255fa3dd964ff5857f713e4972a1", size = 85596 },
+    { url = "https://files.pythonhosted.org/packages/d2/11/678bfe9b57d8d0a3b0f5f01c2cdb52d12ed6dcd157cc6324b084f265ba1b/praisonaiagents-0.0.35-py3-none-any.whl", hash = "sha256:0c0f9650cb67449261738cd7225d5815434bc042cca319e7e7230196b47807cf", size = 86057 },
 ]
 
 [[package]]