Hopping-Mad-Games-ComfyUI_LiteLLM/agents/EXAMPLES.md

Agent Nodes Examples

This file contains simple, concrete examples of how to configure and use the agent nodes in ComfyUI_LiteLLM.

Example 1: Simple Text Enhancement

Goal: Take a basic response and make it more detailed and thoughtful.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "gpt-3.5-turbo"
   
2. LiteLLMCompletionProvider
   - model: [connect from LiteLLMModelProvider]
   
3. BasicRecursionFilterNode (Completion Enhancement Filter)
   - max_depth: 2
   - LLLM_provider: [connect from LiteLLMCompletionProvider]
   - recursion_prompt: (use default or customize)
   
4. AgentNode (Iterative Completion Agent)
   - model: [connect from LiteLLMModelProvider]
   - prompt: "Explain quantum computing to a beginner"
   - max_iterations: 1
   - recursion_filter: [connect from BasicRecursionFilterNode]

Connection Flow: LiteLLMModelProvider → AgentNode
                LiteLLMCompletionProvider → BasicRecursionFilterNode → AgentNode

Expected Behavior:

• Initial completion gives basic quantum computing explanation
• Recursion filter enhances it 2 times, making it more comprehensive
• Final result is a detailed, well-structured explanation

Example 2: Large Document Summarization

Goal: Summarize a long research paper by processing it in chunks.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "gpt-4"
   
2. LiteLLMCompletionProvider
   - model: [connect from LiteLLMModelProvider]
   
3. DocumentChunkRecursionFilterNode
   - LLLM_provider: [connect from LiteLLMCompletionProvider]
   - document: [paste your long document text here]
   - chunk_size: 1000
   - recursion_prompt: 
     "Summarize this chunk: {chunk}
     
     Previous summary: {completion}
     
     Combine and create an updated summary."
   
4. AgentNode
   - model: [connect from LiteLLMModelProvider]
   - prompt: "Please summarize this document"
   - max_iterations: [number of chunks, e.g., 10 for 10k character document]
   - recursion_filter: [connect from DocumentChunkRecursionFilterNode]

Expected Behavior:

• Document gets split into 1000-character chunks
• Each iteration processes one chunk and updates the running summary
• Final result is a comprehensive summary of the entire document

Example 3: Creative Story Development

Goal: Start with a story idea and develop it through multiple iterations.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "claude-3-sonnet"
   
2. LiteLLMCompletionProvider
   - model: [connect from LiteLLMModelProvider]
   
3. BasicRecursionFilterNode
   - max_depth: 3
   - LLLM_provider: [connect from LiteLLMCompletionProvider]
   - recursion_prompt:
     "Given this story prompt: {prompt}
     
     And this current story: {completion}
     
     Enhance the story by:
     1. Adding more character depth
     2. Improving dialogue
     3. Adding sensory details
     4. Developing the plot further
     
     <enhanced_story>
     [Your enhanced version here]
     </enhanced_story>"
   
4. AgentNode
   - model: [connect from LiteLLMModelProvider]
   - prompt: "Write a short story about a time traveler who gets stuck in the past"
   - max_iterations: 2
   - recursion_filter: [connect from BasicRecursionFilterNode]

Expected Behavior:

• First iteration creates basic story
• Each recursion level adds more depth, detail, and polish
• Final story goes through 2 iterations × 3 recursion depths = 6 total enhancements

Example 4: Research Question Analysis

Goal: Thoroughly analyze a complex research question from multiple angles.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "gpt-4"
   
2. LiteLLMCompletionProvider
   - model: [connect from LiteLLMModelProvider]
   
3. BasicRecursionFilterNode
   - max_depth: 2
   - LLLM_provider: [connect from LiteLLMCompletionProvider]
   - recursion_prompt:
     "Research Question: {prompt}
     
     Current Analysis: {completion}
     
     Please expand this analysis by:
     1. Considering alternative perspectives
     2. Identifying potential limitations
     3. Suggesting research methodologies
     4. Adding relevant context
     5. Proposing follow-up questions
     
     Date: {date}
     
     <expanded_analysis>
     [Your expanded analysis here]
     </expanded_analysis>"
   
4. AgentNode
   - model: [connect from LiteLLMModelProvider]
   - prompt: "How might climate change affect urban planning in coastal cities over the next 50 years?"
   - max_iterations: 3
   - recursion_filter: [connect from BasicRecursionFilterNode]

Expected Behavior:

• First iteration provides initial analysis
• Each subsequent iteration deepens the analysis
• Recursion filter adds multiple perspectives and considerations
• Final result is a comprehensive, multi-faceted research analysis

Example 5: Code Review and Enhancement

Goal: Review code and provide iterative improvements.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "gpt-4"
   
2. LiteLLMCompletionProvider
   - model: [connect from LiteLLMModelProvider]
   
3. BasicRecursionFilterNode
   - max_depth: 2
   - LLLM_provider: [connect from LiteLLMCompletionProvider]
   - recursion_prompt:
     "Code to review: {prompt}
     
     Previous review: {completion}
     
     Please enhance this code review by:
     1. Checking for additional bugs or issues
     2. Suggesting performance optimizations
     3. Reviewing security considerations
     4. Proposing better practices
     5. Adding implementation suggestions
     
     <enhanced_review>
     [Your enhanced review here]
     </enhanced_review>"
   
4. AgentNode
   - model: [connect from LiteLLMModelProvider]
   - prompt: [paste your code here]
   - max_iterations: 1
   - recursion_filter: [connect from BasicRecursionFilterNode]

Expected Behavior:

• Initial review identifies basic issues and improvements
• Recursion filter adds deeper analysis and more suggestions
• Final result is a comprehensive code review with multiple improvement suggestions

Example 6: Multi-Prompt Processing

Goal: Process several related prompts together for comparative analysis.

Workflow Setup:

1. LiteLLMModelProvider
   - model: "claude-3-sonnet"
   
2. CreateListFromStrings (or similar list creation node)
   - Create list with prompts:
     - "What are the benefits of remote work?"
     - "What are the challenges of remote work?"
     - "How can companies optimize remote work?"
   
3. AgentNode
   - model: [connect from LiteLLMModelProvider]
   - List_prompts: [connect from list creation node]
   - max_iterations: 2
   - recursion_filter: [leave empty for this example]

Expected Behavior:

• Each prompt gets processed in parallel during each iteration
• Second iteration can build on insights from all prompts
• Final result includes comprehensive analysis of all aspects

Common Recursion Prompt Templates

Analysis Enhancement Template

Original question: {prompt}
Current analysis: {completion}
Date: {date}

Please enhance this analysis by:
1. Adding more depth and detail
2. Considering alternative viewpoints
3. Providing concrete examples
4. Identifying potential limitations
5. Suggesting practical applications

<enhanced_analysis>
[Your enhanced analysis]
</enhanced_analysis>

Creative Writing Template

Story prompt: {prompt}
Current story: {completion}

Improve this story by:
1. Developing characters more fully
2. Adding vivid sensory details
3. Improving dialogue and pacing
4. Strengthening the narrative arc
5. Enhancing emotional impact

<improved_story>
[Your improved story]
</improved_story>

Technical Explanation Template

Topic: {prompt}
Current explanation: {completion}
Date: {date}

Enhance this explanation by:
1. Adding more technical depth
2. Including practical examples
3. Explaining prerequisites and context
4. Addressing common misconceptions
5. Providing implementation guidance

<enhanced_explanation>
[Your enhanced explanation]
</enhanced_explanation>

Document Processing Template

Document chunk: {chunk}
Previous summary: {completion}
Original task: {prompt}

Process this chunk and update the summary:
1. Extract key information from the chunk
2. Integrate it with the previous summary
3. Maintain coherence and flow
4. Highlight important connections

<updated_summary>
[Your updated summary]
</updated_summary>

Tips for Success

1. Start Simple: Begin with basic setups before adding complexity
2. Test Iterations: Try with max_iterations=1 first, then increase
3. Monitor Costs: More iterations and recursion depth = higher API costs
4. Use Caching: Enable use_last_response during development
5. Customize Prompts: Tailor recursion prompts to your specific use case
6. Check Connections: Ensure all CALLABLE inputs are properly connected
7. Gradual Complexity: Add memory providers and nested filters after mastering basics

Troubleshooting Common Issues

Issue: "CALLABLE type not connected" Solution: Make sure LiteLLMCompletionProvider is connected to filter nodes

Issue: Results are too repetitive Solution: Improve recursion prompt templates or reduce max_depth

Issue: High API costs Solution: Reduce max_iterations, max_depth, or use smaller models

Issue: Inconsistent quality Solution: Use more specific recursion prompts and test with different models