Prompt Refiner: Multi-Agent LLM Workflow (CrewAI)

Transform rough ideas into production-ready prompts using intelligent agent orchestration

A sophisticated multi-agent AI system that leverages CrewAI, Ollama, and Flask to convert vague user concepts into structured, optimized LLM prompts through an automated pipeline of clarification, refinement, and validation.

Overview

Prompt Refiner demonstrates advanced AI engineering by orchestrating multiple specialized agents that collaborate to understand user intent and produce high-quality prompts. The system operates entirely offline with local models or seamlessly integrates with cloud providers like OpenAI and Anthropic.

Watch the Full Demo + Code Walkthrough on YouTube →

Key Features

Intelligent Multi-Agent Pipeline

Coordinated CrewAI workflow with specialized agents handling distinct phases:

• Clarification Agent: Analyzes user input and generates targeted questions
• Refinement Agent: Transforms responses into structured prompts
• XML Formatter: Converts prompts to standardized markup
• Validation Agent: Ensures output quality and removes artifacts

Flexible Model Backend

• Local-First: Run completely offline with Ollama + LLaMA 3
• Cloud-Ready: Switch to OpenAI, Anthropic, or other providers instantly
• Environment-Based: Secure API key management through .env configuration

Polished Web Interface

• Clean, responsive Flask application
• Real-time form interactions with loading states
• Error handling and user feedback
• One-click copy-to-clipboard functionality

Production-Ready Architecture

• Modular agent system for easy extension
• Separation of concerns between frontend and backend
• RESTful API design
• Security best practices with environment-based configuration

How It Works

User Input → Clarification → Refinement → XML Formatting → Validation → Final Prompt
     ↓              ↓             ↓              ↓             ↓
  Raw Idea → Targeted Questions → Structured Content → Standardized Format → Quality Assured

1. Input Analysis: User provides a rough idea or goal
2. Intelligent Questioning: System generates clarifying questions to understand intent
3. Structured Refinement: Responses are transformed into a coherent, actionable prompt
4. Format Standardization: Output is converted to XML or other structured formats
5. Quality Validation: Final check ensures prompt clarity and removes any processing artifacts

Technical Stack

| Component | Technology | Purpose | |-----------|------------|---------| | Agent Orchestration | CrewAI | Multi-agent workflow coordination | | LLM Backend | Ollama/OpenAI/Anthropic | Language model inference | | Web Framework | Flask + Jinja2 | Backend API and templating | | Frontend | HTML/CSS/Vanilla JS | User interface and interactions | | Configuration | Python-dotenv | Environment management |

Quick Start

Prerequisites

• Python 3.8+
• Ollama (for local inference) or API keys for cloud providers

Installation

1. Clone the repository

   git clone <repository-url>
   cd prompt-refiner
   

2. Install dependencies

   pip install -r requirements.txt
   

3. Configure environment

   cp .env.example .env
   # Edit .env with your preferred settings
   

4. Run the application

   python app.py
   

5. Open your browser Navigate to http://localhost:5000

Configuration

Local Inference (Ollama)

llm = LLM(
    model="llama3:8b",
    base_url="http://localhost:11434",
    temperature=0.2,
    custom_llm_provider="ollama"
)

Cloud Inference (OpenAI)

llm = LLM(
    model="gpt-4o",
    base_url=os.getenv("OPENAI_BASE_URL"),
    temperature=0.2,
    custom_llm_provider="openai",
    api_key=os.getenv("OPENAI_API_KEY")
)

Environment Variables

OPENAI_BASE_URL=https://api.openai.com/v1
OPENAI_API_KEY=sk-your-key-here
ANTHROPIC_API_KEY=sk-ant-your-key-here

Project Structure

prompt-refiner/
├── app.py              # Flask server + pipeline orchestration
├── agents.py           # Agent definitions and behaviors
├── tasks.py            # Task logic for each agent
├── templates/
│   └── index.html      # Web interface
├── static/
│   ├── style.css       # Application styles
│   └── script.js       # Frontend interactions
├── .env.example        # Environment template
├── requirements.txt    # Python dependencies
└── README.md          # This file

Skills Demonstrated

AI/ML Engineering

• Multi-Agent Systems: Coordinated agent workflows with CrewAI
• Prompt Engineering: Advanced prompt design and optimization techniques
• LLM Integration: Flexible backend switching between local and cloud models
• Agent Orchestration: Stateful pipeline management and task delegation

Full-Stack Development

• Backend Architecture: RESTful Flask API with proper separation of concerns
• Frontend Engineering: Responsive UI with async JavaScript and real-time feedback
• State Management: Handling complex multi-step user workflows
• Error Handling: Comprehensive error states and user feedback

DevOps & Security

• Environment Management: Secure API key handling and configuration
• Local Development: Docker-ready setup with hot reloading
• Production Patterns: Logging, monitoring, and deployment considerations

Extension Ideas

The modular architecture makes the system highly extensible. Here are some enhancement opportunities:

Intelligence Enhancements

• Memory Integration: Vector database for session persistence and learning
• Quality Scoring: Automated prompt evaluation and iterative improvement
• Context Injection: Document upload and content incorporation
• Multi-Modal Support: Image and file input processing

Workflow Improvements

• Conditional Logic: Dynamic agent routing based on content type
• Feedback Loops: User rating system for continuous improvement
• Template Library: Pre-built prompt templates and personas
• Batch Processing: Handle multiple prompts simultaneously

Platform Extensions

• API Gateway: RESTful API for external integrations
• Multi-Language: Internationalization and translation support
• Team Features: Collaboration tools and shared prompt libraries
• Analytics Dashboard: Usage metrics and performance insights

Integration Options

• LangGraph Migration: Event-driven orchestration for complex workflows
• Database Layer: Persistent storage for prompts and user sessions
• Authentication: User management and access control
• Third-Party APIs: Integration with popular productivity tools

Performance Considerations

• Local Models: ~2-5 second response times with LLaMA 3 8B
• Cloud Models: ~1-3 second response times (network dependent)
• Memory Usage: ~2-4GB RAM for local inference
• Scalability: Stateless design supports horizontal scaling