Skip to content

README.md

Latest commit

 

History

History
245 lines (181 loc) · 8.13 KB

README.md

File metadata and controls

245 lines (181 loc) · 8.13 KB

Agentic Patterns

This project demonstrates practical implementations of the workflow patterns for building effective LLM-based systems, as described in Anthropic's research on building effective agents.

Overview

The project provides concrete implementations of five fundamental workflow patterns that can be used to build effective LLM-based systems. Each pattern is implemented as a separate module with its own specific use cases and benefits.

Workflow Patterns

1. Chain Workflow

chain-workflow/

Implements prompt chaining to decompose tasks into a sequence of LLM calls where each step processes the output of the previous one. Ideal for tasks that can be cleanly broken down into fixed subtasks.

When to Use:

  • Tasks with clear sequential steps
  • When you want to trade latency for higher accuracy
  • When each step builds on the previous step's output

Example Applications:

  • Data transformation pipelines
  • Multi-step text processing
  • Document generation with structured steps

2. Parallelization Workflow

parallelization-workflow/

Enables concurrent processing of multiple LLM operations with two key variations:

  • Sectioning: Breaking tasks into independent subtasks run in parallel
  • Voting: Running the same task multiple times to get diverse outputs

When to Use:

  • Processing large volumes of similar but independent items
  • Tasks requiring multiple independent perspectives
  • When processing time is critical and tasks are parallelizable

Example Applications:

  • Batch processing of documents
  • Multi-perspective content analysis
  • Parallel validation checks

3. Routing Workflow

routing-workflow/

Implements a classification system that directs input to specialized followup tasks, enabling separation of concerns and optimized processing for different types of input.

When to Use:

  • Complex tasks with distinct categories of input
  • When different inputs require specialized processing
  • When classification can be handled accurately

Example Applications:

  • Customer support ticket routing
  • Content moderation systems
  • Query optimization based on complexity

4. Orchestrator-Workers

orchestrator-workers/

Implements a flexible system where a central LLM orchestrates task decomposition and delegates to specialized worker LLMs.

When to Use:

  • Complex tasks where subtasks can't be predicted upfront
  • Tasks requiring different approaches or perspectives
  • Situations needing adaptive problem-solving

Example Applications:

  • Complex code generation tasks
  • Multi-source research tasks
  • Adaptive content creation

5. Evaluator-Optimizer

evaluator-optimizer/

Implements an iterative refinement process where one LLM generates solutions while another provides evaluation and feedback.

When to Use:

  • Clear evaluation criteria exist
  • Iterative refinement provides measurable value
  • Tasks benefit from multiple rounds of critique

Example Applications:

  • Code review and improvement
  • Content quality optimization
  • Translation refinement
  • Complex search tasks

Implementation Details

All workflows are implemented using:

  • Spring AI for LLM interactions
  • Spring Boot for application framework
  • Java 17+ for modern language features

Each workflow module contains:

  • Core workflow implementation
  • Usage examples
  • Customization options
  • Unit tests

Getting Started

  1. Clone the repository
  2. Choose the appropriate workflow pattern for your use case
  3. See the individual module's README for specific implementation details

Spring AI Features

This project leverages several key features from Spring AI to implement the workflow patterns effectively:

  1. ChatClient Interface: Core abstraction for interacting with LLM models

    • Consistent API across different LLM providers
    • Fluent interface for prompt construction
    • Built-in retry and error handling

  2. Model Support: Wide range of supported LLM providers

    • OpenAI (GPT models)
    • Azure OpenAI
    • Anthropic (Claude models)
    • Ollama (local models)
    • And more...

  3. Structured Output: Type-safe handling of LLM responses

    • Convert JSON responses to Java objects
    • Strongly-typed response handling
    • Validation and error handling

  4. Prompt Management: Flexible prompt handling

    • Template-based prompts
    • System and user message separation
    • Context management

These features provide a robust foundation for building reliable and maintainable LLM-based applications.

Spring AI Model Portability

The workflows in this project are model-agnostic and can work with any of the chat models supported by Spring AI. To switch between different models:

  1. Replace the model-specific starter dependency in your pom.xml:
<!-- OpenAI -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>

<!-- Azure OpenAI -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
</dependency>

<!-- Anthropic -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-anthropic-spring-boot-starter</artifactId>
</dependency>

<!-- Ollama -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
</dependency>
  1. Configure the model-specific properties in your application.properties:
# OpenAI Configuration
spring.ai.openai.api-key=your-api-key
spring.ai.openai.model=gpt-3.5-turbo

# Azure OpenAI Configuration
spring.ai.azure.openai.api-key=your-api-key
spring.ai.azure.openai.endpoint=your-endpoint
spring.ai.azure.openai.model=gpt-35-turbo

# Anthropic Configuration
spring.ai.anthropic.api-key=your-api-key
spring.ai.anthropic.model=claude-3-opus-20240229

# Ollama Configuration
spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.model=llama3.2:latest

Detailed configuration options for each model can be found in the Spring AI Chat Models documentation.

Spring AI Structured Output

Several patterns in this project use Spring AI's Structured Output Converter to handle structured responses from LLMs. This feature allows for:

  • Converting LLM responses into strongly-typed Java objects
  • Ensuring consistent response formats
  • Type-safe handling of LLM outputs

Example Usage

// Define a record for structured output
public record EvaluationResponse(Evaluation evaluation, String feedback) {
    public enum Evaluation {
        PASS, NEEDS_IMPROVEMENT, FAIL
    }
}

// Use the entity() method to convert response to your type
EvaluationResponse response = chatClient.prompt(prompt)
    .call()
    .entity(EvaluationResponse.class);

// Access typed fields
if (response.evaluation() == Evaluation.PASS) {
    // Handle passing evaluation
}

Implementation Examples

The feature is used in several workflow patterns:

  1. Evaluator-Optimizer Workflow: Structures evaluation responses with pass/fail status and feedback
record EvaluationResponse(Evaluation evaluation, String feedback)
  1. Routing Workflow: Structures routing decisions with reasoning and selection
record RoutingResponse(String reasoning, String selection)
  1. Chain Workflow: Structures intermediate transformation results
record TransformationResult(String output, List<String> steps)

References