Merge pull request #713 from MervinPraison/claude/issue-66-20250628_222152

MervinPraison · web-flow · commit e34b00a9a89c · 2025-06-28T23:28:19.000+01:00
feat: add input variable value examples
diff --git a/examples/python/input/advanced_dynamic_input.py b/examples/python/input/advanced_dynamic_input.py
@@ -0,0 +1,163 @@
+"""
+Advanced Dynamic Input Example for PraisonAI
+
+This example demonstrates an advanced system that dynamically creates agents and tasks
+based on user inputs, including conditional logic, custom configurations, and file output.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+import os
+from typing import Dict, List
+
+class DynamicAgentSystem:
+    """Advanced system for handling dynamic user inputs"""
+    
+    def __init__(self):
+        self.user_preferences = {}
+        self.llm_config = {
+            "model": os.getenv("LLM_MODEL", "gpt-4o-mini"),
+            "temperature": 0.7
+        }
+    
+    def collect_user_inputs(self) -> Dict[str, str]:
+        """Collect multiple user inputs"""
+        inputs = {}
+        inputs['topic'] = input("What topic would you like to explore? ")
+        inputs['depth'] = input("Analysis depth (quick/detailed)? ").lower() or "quick"
+        inputs['output_format'] = input("Output format (summary/report/bullets)? ").lower() or "summary"
+        inputs['language'] = input("Language preference (en/es/fr)? ").lower() or "en"
+        return inputs
+    
+    def create_dynamic_agents(self, inputs: Dict[str, str]) -> List[Agent]:
+        """Create agents based on user inputs"""
+        agents = []
+        
+        # Research agent with dynamic configuration
+        research_agent = Agent(
+            name="ResearchExpert",
+            role=f"{'Detailed' if inputs['depth'] == 'detailed' else 'Quick'} Research Specialist",
+            goal=f"Conduct {inputs['depth']} research on {inputs['topic']} in {inputs['language']}",
+            backstory=f"Multilingual expert specializing in {inputs['depth']} analysis",
+            tools=[duckduckgo],
+            self_reflect=inputs['depth'] == 'detailed',
+            llm=self.llm_config
+        )
+        agents.append(research_agent)
+        
+        # Format agent based on output preference
+        format_agent = Agent(
+            name="FormatExpert",
+            role=f"{inputs['output_format'].title()} Formatter",
+            goal=f"Format research into {inputs['output_format']} style",
+            backstory=f"Expert in creating {inputs['output_format']} documents",
+            llm=self.llm_config
+        )
+        agents.append(format_agent)
+        
+        # Optional quality agent for detailed analysis
+        if inputs['depth'] == 'detailed':
+            quality_agent = Agent(
+                name="QualityChecker",
+                role="Quality Assurance Specialist",
+                goal="Verify accuracy and completeness",
+                backstory="Expert in fact-checking and quality control",
+                llm=self.llm_config
+            )
+            agents.append(quality_agent)
+        
+        return agents
+    
+    def create_dynamic_tasks(self, agents: List[Agent], inputs: Dict[str, str]) -> List[Task]:
+        """Create tasks based on user inputs and agents"""
+        tasks = []
+        
+        # Research task
+        research_task = Task(
+            description=f"""
+            Research '{inputs['topic']}' with the following requirements:
+            - Depth: {inputs['depth']}
+            - Language: {inputs['language']}
+            - Find {'5-10' if inputs['depth'] == 'detailed' else '3-5'} key points
+            - Include sources and citations
+            """,
+            expected_output=f"Research findings about {inputs['topic']} with sources",
+            agent=agents[0],  # Research agent
+            name="research_phase"
+        )
+        tasks.append(research_task)
+        
+        # Formatting task
+        format_instructions = {
+            'summary': "Create a concise paragraph summary",
+            'report': "Create a structured report with sections",
+            'bullets': "Create a bullet-point list of key findings"
+        }
+        
+        format_task = Task(
+            description=f"""
+            Format the research findings as follows:
+            - Style: {format_instructions[inputs['output_format']]}
+            - Language: {inputs['language']}
+            - Maintain all source citations
+            """,
+            expected_output=f"{inputs['output_format'].title()} of {inputs['topic']}",
+            agent=agents[1],  # Format agent
+            context=[research_task],
+            name="formatting_phase"
+        )
+        tasks.append(format_task)
+        
+        # Quality check task (if detailed)
+        if inputs['depth'] == 'detailed' and len(agents) > 2:
+            quality_task = Task(
+                description="Verify all facts, check sources, and ensure completeness",
+                expected_output="Quality-assured final output with verification notes",
+                agent=agents[2],  # Quality agent
+                context=[format_task],
+                name="quality_phase"
+            )
+            tasks.append(quality_task)
+        
+        return tasks
+    
+    def run(self):
+        """Main execution flow"""
+        # Collect inputs
+        print("🎯 PraisonAI Dynamic Input System")
+        print("-" * 40)
+        inputs = self.collect_user_inputs()
+        
+        # Create dynamic agents and tasks
+        agents = self.create_dynamic_agents(inputs)
+        tasks = self.create_dynamic_tasks(agents, inputs)
+        
+        # Configure process based on depth
+        process = "hierarchical" if inputs['depth'] == 'detailed' else "sequential"
+        
+        # Run the system
+        print(f"\n🚀 Starting {process} analysis for '{inputs['topic']}'...")
+        praison_agents = PraisonAIAgents(
+            agents=agents,
+            tasks=tasks,
+            process=process,
+            verbose=inputs['depth'] == 'detailed'
+        )
+        
+        result = praison_agents.start()
+        
+        # Save results if detailed
+        if inputs['depth'] == 'detailed':
+            filename = f"{inputs['topic'].replace(' ', '_')}_{inputs['output_format']}.txt"
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(result)
+            print(f"\n📄 Results saved to: {filename}")
+        
+        return result
+
+# Usage
+if __name__ == "__main__":
+    system = DynamicAgentSystem()
+    result = system.run()
+    print("\n📊 Final Result:")
+    print(result)
diff --git a/examples/python/input/environment_variable_input.py b/examples/python/input/environment_variable_input.py
@@ -0,0 +1,60 @@
+"""
+Environment Variable Input Example for PraisonAI
+
+This example demonstrates how to use environment variables combined with user input
+to create flexible agent configurations that can be pre-configured via environment.
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Set via environment or use default
+default_topic = os.getenv("RESEARCH_TOPIC", "AI trends")
+user_topic = input(f"Topic to research [{default_topic}]: ") or default_topic
+
+# Get other configuration from environment
+llm_model = os.getenv("LLM_MODEL", "gpt-4o-mini")
+temperature = float(os.getenv("LLM_TEMPERATURE", "0.7"))
+max_retries = int(os.getenv("MAX_RETRIES", "3"))
+
+# Create agent with environment-based configuration
+agent = Agent(
+    name="Researcher",
+    role="Research Assistant",
+    goal=f"Research {user_topic}",
+    backstory="Expert researcher with configurable capabilities",
+    llm={
+        "model": llm_model,
+        "temperature": temperature
+    },
+    max_retry_limit=max_retries
+)
+
+# Create task
+task = Task(
+    description=f"Research and summarize: {user_topic}",
+    expected_output="Comprehensive summary with key findings",
+    agent=agent
+)
+
+# Show configuration
+print(f"\n🔧 Configuration:")
+print(f"  - Topic: {user_topic}")
+print(f"  - Model: {llm_model}")
+print(f"  - Temperature: {temperature}")
+print(f"  - Max Retries: {max_retries}")
+print("\n" + "="*50 + "\n")
+
+# Run agents
+agents = PraisonAIAgents(agents=[agent], tasks=[task])
+result = agents.start()
+
+# Save to environment-specified location if provided
+output_path = os.getenv("OUTPUT_PATH")
+if output_path:
+    output_file = os.path.join(output_path, f"{user_topic.replace(' ', '_')}_research.txt")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(result)
+    print(f"\n📁 Results saved to: {output_file}")
+
+print("\n✅ Research completed!")
diff --git a/examples/python/input/medium_complexity_input.py b/examples/python/input/medium_complexity_input.py
@@ -0,0 +1,55 @@
+"""
+Medium Complexity Input Example for PraisonAI
+
+This example shows how to use multiple user inputs to create a more sophisticated
+agent system with tools, multiple agents, and context passing between tasks.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+
+# Get multiple inputs
+topic = input("Enter search topic: ")
+num_results = input("How many results? (default: 5): ") or "5"
+
+# Create search agent with tools
+search_agent = Agent(
+    name="WebSearcher",
+    role="Search Specialist",
+    goal=f"Find {num_results} relevant results about {topic}",
+    backstory="Expert in internet research and data collection",
+    tools=[duckduckgo],
+    self_reflect=False
+)
+
+# Create analysis agent
+analysis_agent = Agent(
+    name="Analyzer",
+    role="Data Analyst",
+    goal="Analyze and summarize search results",
+    backstory="Expert in data synthesis and reporting"
+)
+
+# Create tasks with context passing
+search_task = Task(
+    description=f"Search for '{topic}' and find top {num_results} results",
+    expected_output=f"List of {num_results} relevant results with sources",
+    agent=search_agent,
+    name="search_task"
+)
+
+analyze_task = Task(
+    description="Analyze the search results and create a summary report",
+    expected_output="Comprehensive summary with key insights",
+    agent=analysis_agent,
+    context=[search_task],  # Receives results from search_task
+    name="analysis_task"
+)
+
+# Run sequential process
+agents = PraisonAIAgents(
+    agents=[search_agent, analysis_agent],
+    tasks=[search_task, analyze_task],
+    process="sequential"
+)
+agents.start()
diff --git a/examples/python/input/simple_input.py b/examples/python/input/simple_input.py
@@ -0,0 +1,30 @@
+"""
+Simple Input Example for PraisonAI
+
+This example demonstrates how to use basic user input to create dynamic agents and tasks.
+The user is prompted for a search query, and the agent searches for information about it.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Get user input
+user_query = input("What would you like to search for? ")
+
+# Create agent
+agent = Agent(
+    name="SearchAgent",
+    role="Information Finder",
+    goal="Find information about user's query",
+    backstory="Expert researcher with web access"
+)
+
+# Create task with dynamic input
+task = Task(
+    description=f"Search for information about: {user_query}",
+    expected_output=f"Summary of findings about {user_query}",
+    agent=agent
+)
+
+# Run
+agents = PraisonAIAgents(agents=[agent], tasks=[task])
+agents.start()
diff --git a/examples/python/input/streamlit_ui_input.py b/examples/python/input/streamlit_ui_input.py
