Visual flow builder for AI prompt engineering—a comprehensive platform with drag-and-drop interface to create, test, and optimize prompt flows with real-time execution. Solves iteration bottlenecks with Git-like versioning, A/B testing, and semantic search. Multi-database architecture (MongoDB + Qdrant + Redis) enables enterprise-grade flexibility, self-hosted security, and vendor independence. Built for prompt engineers seeking rapid experimentation without vendor lock-in.

• Visual Flow Builder - Drag-and-drop interface for creating prompt flows
• Multi-Model Support - OpenAI, Azure OpenAI, Anthropic, and more
• A/B Testing & Evaluation - Compare prompt variants with statistical analysis
• Vector Search - Semantic search with Qdrant vector database
• Real-time Execution - Fast prompt execution with caching
• Version Control - Track and manage prompt flow versions
• Analytics Dashboard - Monitor performance and usage metrics

Unlike traditional prompt flow tools that force you into rigid SQL schemas, our solution provides:

• NoSQL-first design (MongoDB + Qdrant + Redis)
• Purpose-built for prompt engineering flexibility
• Vector database integration for semantic search
• Schema-less rapid iteration capabilities

Choose the right database for each use case:

• MongoDB: Flexible prompt storage and experimentation
• Qdrant: Vector embeddings & semantic search
• Redis: Real-time caching & execution status
• PostgreSQL (Optional): Structured metadata when needed

Every feature is optimized for prompt workflows:

• Rapid Iteration: Schema-less prompt templates
• Version Control: Git-like prompt versioning with semantic diff
• Semantic Search: Find similar prompts via embeddings
• A/B Testing: Built-in prompt experiment tracking
• Performance Analytics: Prompt effectiveness metrics

vs Azure Prompt Flow:

• ✅ Vendor Independence: Not locked to Azure ecosystem
• ✅ Cost Control: No per-execution charges or usage fees
• ✅ Data Privacy: Full control over sensitive prompts and data

vs Open Source (Langflow/Flowise):

• ✅ Production Ready: Enterprise-grade database stack out of the box
• ✅ Prompt-Focused: Built specifically for prompt engineering workflows
• ✅ Performance: Vector search + caching optimized for prompt operations

vs Building In-House:

• ✅ Time to Market: Ready-to-deploy solution with best practices
• ✅ Proven Architecture: Battle-tested patterns for prompt applications
• ✅ Community: Ongoing updates and community contributions

For Prompt Engineers

# Your workflow becomes:
workflow = {
    "discover": "Semantic search existing prompts",
    "iterate": "No schema constraints, rapid changes", 
    "track": "Every prompt change versioned",
    "analyze": "Built-in A/B testing and metrics"
}

• Data Sovereignty: Complete control over prompt intellectual property
• Security: Self-hosted, no data leaves your infrastructure
• Scalability: NoSQL horizontal scaling for growing prompt libraries
• Compliance: Meet data residency and privacy requirements

• Modern Stack: FastAPI + React + Poetry for excellent developer experience
• Type Safety: Full TypeScript + Pydantic for robust applications
• Hot Reload: Instant feedback during development
• Extensibility: Plugin architecture for custom node types

Modern Layered Architecture:

• Frontend: React + TypeScript for type-safe UI development
• API Gateway: FastAPI with automatic OpenAPI documentation
• Services: Microservice-oriented business logic separation
• Databases: Multi-database strategy optimized for different data types
• External APIs: Seamless integration with AI service providers

Data Flow Mapping:

Intelligent Traffic Routing:

• React 18: Modern React with hooks and concurrent features
• TypeScript: Type-safe development with excellent IDE support
• Vite: Lightning-fast development server and build tool
• React Flow: Professional node-based editor for visual flows
• Tailwind CSS: Utility-first CSS framework for rapid styling
• Zustand: Lightweight state management without boilerplate
• React Query: Server state management with caching and synchronization

• FastAPI: Modern, fast Python web framework with automatic API docs
• Python 3.11+: Latest Python features and performance improvements
• Pydantic: Data validation using Python type annotations
• Poetry: Dependency management and packaging
• Uvicorn: Lightning-fast ASGI server implementation

NoSQL Primary Stack:
  mongodb: "Document storage for flows, prompts, and metadata"
  qdrant: "Vector database for semantic search and embeddings"
  redis: "Caching, sessions, and real-time data"

SQL Optional Stack:
  postgresql: "Structured analytics and complex queries"
  alembic: "Database migrations and schema management"

• Docker: Containerization for consistent deployment
• Docker Compose: Multi-service orchestration
• Poetry: Python dependency and virtual environment management
• Pytest: Comprehensive testing framework
• Black: Code formatting for consistent style
• Ruff: Fast Python linter for code quality

prompt-flow/
├── 📁 frontend/                 # React TypeScript frontend
│   ├── 📁 src/
│   │   ├── 📁 components/       # Reusable UI components
│   │   ├── 📁 pages/           # Route-based page components
│   │   ├── 📁 hooks/           # Custom React hooks
│   │   ├── 📁 store/           # Zustand state management
│   │   ├── 📁 types/           # TypeScript type definitions
│   │   └── 📁 utils/           # Utility functions and helpers
│   ├── 📄 package.json
│   ├── 📄 vite.config.ts
│   └── 📄 tailwind.config.js
│
├── 📁 backend/                  # FastAPI Python backend
│   ├── 📁 app/
│   │   ├── 📁 api/             # API route definitions
│   │   │   ├── 📁 v1/          # API version 1 endpoints
│   │   │   └── 📄 deps.py      # Dependency injection
│   │   ├── 📁 core/            # Core application logic
│   │   │   ├── 📄 config.py    # Configuration management
│   │   │   └── 📄 security.py  # Authentication & security
│   │   ├── 📁 db/              # Database connections and models
│   │   │   ├── 📄 mongodb.py   # MongoDB connection
│   │   │   ├── 📄 qdrant.py    # Qdrant vector database
│   │   │   └── 📄 redis.py     # Redis connection
│   │   ├── 📁 models/          # Pydantic data models
│   │   ├── 📁 services/        # Business logic services
│   │   └── 📄 main.py          # FastAPI application entry
│   ├── 📄 pyproject.toml       # Poetry dependencies
│   └── 📄 Dockerfile
│
├── 📁 docs/                     # Documentation
│   ├── 📁 api/                 # API documentation
│   ├── 📁 deployment/          # Deployment guides
│   └── 📁 diagrams/            # Architecture diagrams
│
├── 📁 scripts/                  # Utility scripts
│   ├── 📄 setup.sh            # Development setup
│   └── 📄 deploy.sh           # Deployment automation
│
├── 📄 docker-compose.yml       # Multi-service orchestration
├── 📄 docker-compose.dev.yml   # Development environment
└── 📄 README.md               # This file

• Node.js 18+ and npm/yarn
• Python 3.11+ and Poetry
• Docker and Docker Compose

We provide two Docker Compose configurations for different development workflows:

Use this when you want everything containerized for production-like testing:

# Start complete application stack
docker-compose up -d

# Or with explicit profile (frontend + backend + databases)
docker-compose --profile full up -d

# Just databases (MongoDB, Qdrant, Redis)
docker-compose up -d mongodb qdrant redis

# Stop everything
docker-compose down

What this includes:

• ✅ All databases (MongoDB, Qdrant, Redis)
• ✅ Backend API (containerized)
• ✅ Frontend React app (containerized)
• ✅ Full networking between services

Use when:

• Testing the complete system
• Production-like environment
• CI/CD pipeline testing
• When you don't want to install Node.js/Python locally

Use this for local development when you want to run frontend/backend locally:

# Start only databases for local development
docker-compose -f docker-compose.dev.yml up -d

# Stop databases
docker-compose -f docker-compose.dev.yml down

# View database logs
docker-compose -f docker-compose.dev.yml logs mongodb

What this includes:

• ✅ MongoDB (development instance)
• ✅ Qdrant (vector database)
• ✅ Redis (caching)
• ✅ PostgreSQL (optional analytics)
• ❌ No backend API container
• ❌ No frontend container

Use when:

• Local development with hot reload
• Debugging with IDE breakpoints
• Faster iteration cycles
• Learning the codebase

# Copy environment file
cp backend/.env.example backend/.env
# Edit backend/.env with your API keys

# Start everything
docker-compose up -d --build

# Access applications
# Frontend: http://localhost:3000
# Backend API: http://localhost:8000
# API Docs: http://localhost:8000/docs

# View logs
docker-compose logs -f backend
docker-compose logs -f frontend

# Terminal 1: Start databases only
docker-compose -f docker-compose.dev.yml up -d

# Terminal 2: Run backend locally
cd backend
poetry install
poetry shell
cp .env.example .env
# Edit .env with your configuration
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

# Terminal 3: Run frontend locally
cd frontend
npm install
npm run dev

# Access applications
# Frontend: http://localhost:3000 (local dev server)
# Backend: http://localhost:8000 (local Python server)
# Databases: Running in Docker containers

# Start databases + backend in containers, frontend locally
docker-compose up -d mongodb qdrant redis backend

# Run frontend locally for better dev experience
cd frontend
npm install
npm run dev

Both Docker Compose files use the same environment configuration:

# Copy and edit the environment file
cp backend/.env.example backend/.env

# Required: Add your AI service API keys
OPENAI_API_KEY=your-openai-api-key-here
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
AZURE_OPENAI_API_KEY=your-azure-openai-api-key

# Database URLs (automatically configured for Docker)
MONGODB_URL=mongodb://admin:password123@mongodb:27017/prompt_flow?authSource=admin
QDRANT_URL=http://qdrant:6333
REDIS_URL=redis://redis:6379

# Security
SECRET_KEY=your-super-secret-key-change-in-production

We provide comprehensive troubleshooting tools for both platforms to handle common issues:

For the most common Poetry package-mode compatibility issue:

# For Linux/macOS/Git Bash users
./scripts/quick-fix.sh

# For Windows PowerShell users
.\scripts/quick-fix.ps1

What the Quick Fix scripts do:

• ✅ Stops running containers and cleans Docker cache
• ✅ Fixes Poetry compatibility issues (removes unsupported package-mode)
• ✅ Rebuilds backend image with proper configuration
• ✅ Starts all services and verifies health
• ✅ Tests connectivity to ensure everything works

For in-depth troubleshooting and diagnostics:

# For Linux/macOS/Git Bash users
chmod +x debug-poetry.sh
./debug-poetry.sh

# For Windows PowerShell users
.\debug-poetry.ps1

What the Debug scripts do:

• 🔍 Checks Poetry environment info and configuration
• 📦 Lists installed packages in the container
• 🔍 Verifies uvicorn installation and accessibility
• 🧪 Tests app imports and module loading
• 📊 Reports detailed diagnostics for troubleshooting

For complete environment setup from scratch:

# For Linux/macOS/Git Bash users
./scripts/setup.sh

# For Windows PowerShell users
.\scripts\setup.ps1

What the Setup scripts do:

• ✅ Checks prerequisites (Docker, Docker Compose)
• ✅ Creates environment files from templates
• ✅ Fixes Poetry compatibility automatically
• ✅ Builds and starts all services from scratch
• ✅ Performs health checks and verifies connectivity
• ✅ Provides next steps and usage instructions

Follow this order when encountering issues:

1. 🔧 Try Quick Fix first (most common issues):

   ./scripts/quick-fix.sh     # Linux/macOS
   .\scripts\quick-fix.ps1    # Windows

2. 🔍 Use Debug scripts for diagnostics:

   ./debug-poetry.sh          # Linux/macOS
   .\debug-poetry.ps1         # Windows

3. ⚙️ Full setup as last resort:

   ./scripts/setup.sh         # Linux/macOS
   .\scripts\setup.ps1         # Windows

"Command not found: uvicorn" Error:

# First try: Quick fix (handles 90% of cases)
./scripts/quick-fix.sh      # Linux/macOS
.\scripts\quick-fix.ps1     # Windows

# If that doesn't work: Debug for details
./debug-poetry.sh           # Linux/macOS
.\debug-poetry.ps1          # Windows

# Last resort: Full rebuild
docker-compose build --no-cache backend
docker-compose up -d backend

Poetry package-mode Error:

# Automated fix (recommended)
./scripts/quick-fix.sh      # Linux/macOS
.\scripts\quick-fix.ps1     # Windows

# Manual fix: Edit backend/pyproject.toml
# Remove line: package-mode = false
# Then rebuild: docker-compose build --no-cache backend

Port Conflicts:

# Linux/macOS
sudo lsof -i :8000
sudo kill -9 <PID>

# Windows
netstat -ano | findstr :8000
taskkill /PID <PID> /F

Database Connection Issues:

# Check container status (cross-platform)
docker-compose ps
docker-compose logs mongodb
docker-compose logs backend

# Restart specific services
docker-compose restart mongodb
docker-compose restart backend

Clean Restart (cross-platform):

# Nuclear option - use setup script for complete refresh
./scripts/setup.sh          # Linux/macOS
.\scripts/setup.ps1         # Windows

# Or manual clean restart
docker-compose down -v
docker-compose -f docker-compose.dev.yml down -v
docker system prune -f
docker-compose build --no-cache
docker-compose up -d

Platform-Specific File Permissions:

# Linux/macOS - fix script permissions
chmod +x debug-poetry.sh
chmod +x scripts/*.sh

# Windows - no action needed for .ps1 files
# But you may need to enable script execution:
# Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

The project includes automatic MongoDB database setup with sample data:

MongoDB Initialization Script: scripts/init-mongo.js

• Automatic Setup: Creates collections and indexes on first container startup
• Sample Data: Includes example flows, prompts, and users for development
• Schema Validation: Enforces data integrity with MongoDB schema validation
• Performance Optimization: Creates proper indexes for fast queries

What gets created:

• ✅ Collections: flows, flow_executions, prompts, experiments, experiment_results, users
• ✅ Indexes: Optimized for common query patterns
• ✅ Sample Data: Welcome flow, prompt templates, admin user
• ✅ Schema Validation: Ensures data consistency

View initialization logs:

# Check MongoDB initialization
docker-compose logs mongodb

# Connect to MongoDB to verify setup
docker-compose exec mongodb mongosh prompt_flow --eval "show collections"

# Check sample data
docker-compose exec mongodb mongosh prompt_flow --eval "db.flows.findOne()"

The project supports development on Windows, macOS, and Linux:

Windows Users:

• Use PowerShell for best experience
• Scripts: .\debug-poetry.ps1, .\scripts\setup.ps1, .\scripts\quick-fix.ps1
• Docker Desktop with WSL2 backend recommended

macOS/Linux Users:

• Use Terminal/Bash
• Scripts: ./debug-poetry.sh, ./scripts/setup.sh, ./scripts/quick-fix.sh
• Docker Desktop or Docker Engine

Universal Commands:

# These work on all platforms
docker-compose up -d
docker-compose logs -f backend
docker-compose down

Platform-Specific Setup:

1. Access the Flow Builder

   • Open http://localhost:3000
   • Click "Create New Flow"

2. Add Nodes to Your Flow

   [Input] → [Prompt Node] → [LLM Node] → [Output]
   

3. Configure Prompt Node

   Node Type: Prompt
   Template: "Analyze the following text for sentiment: {input_text}"
   Variables: ["input_text"]

4. Configure LLM Node

   Node Type: LLM
   Provider: Azure OpenAI
   Model: gpt-4
   Temperature: 0.7
   Max Tokens: 500

5. Execute and Test

   • Connect nodes with drag-and-drop
   • Click "Run Flow" to execute
   • View real-time results in the output panel

Semantic Search for Prompts:

# Search for similar prompts using embeddings
POST /api/v1/prompts/search
{
  "query": "sentiment analysis prompt",
  "limit": 10,
  "threshold": 0.8
}

A/B Testing Setup:

# Create an experiment
POST /api/v1/experiments
{
  "name": "Prompt Optimization Test",
  "variants": [
    {"name": "original", "prompt_id": "prompt_123", "traffic_percent": 50},
    {"name": "optimized", "prompt_id": "prompt_124", "traffic_percent": 50}
  ],
  "success_metrics": ["response_time", "user_satisfaction"]
}

Version Management:

# Create a new prompt version
POST /api/v1/prompts/{prompt_id}/versions
{
  "template": "Improved prompt template with better instructions...",
  "changes": "Added more specific guidance for edge cases",
  "parent_version": "v1.2.0"
}

# API Key Authentication
headers = {
    "Authorization": "Bearer your-api-key-here",
    "Content-Type": "application/json"
}

# Example request
import requests

response = requests.post(
    "http://localhost:8000/api/v1/flows/execute",
    headers=headers,
    json={"flow_id": "flow_123", "inputs": {"text": "Hello world"}}
)

// Connect to real-time execution updates
const ws = new WebSocket('ws://localhost:8000/ws/execution/{execution_id}');

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  console.log('Execution update:', update);
  // Handle real-time status updates
};

# Production build and deployment
docker-compose -f docker-compose.prod.yml up -d

# Environment configuration
cp .env.production.example .env.production
# Configure production settings:
# - Database connection strings
# - API keys and secrets
# - Scaling parameters

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prompt-flow-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: prompt-flow-api
  template:
    metadata:
      labels:
        app: prompt-flow-api
    spec:
      containers:
      - name: api
        image: prompt-flow/backend:latest
        ports:
        - containerPort: 8000
        env:
        - name: MONGODB_URL
          valueFrom:
            secretKeyRef:
              name: prompt-flow-secrets
              key: mongodb-url

• End-to-end encryption for sensitive prompt data
• Role-based access control (RBAC) for team management
• Audit logging for compliance and security monitoring
• API key rotation and secure credential management

# Production security checklist:
✅ Enable HTTPS/TLS encryption
✅ Configure firewall rules
✅ Set up API rate limiting
✅ Enable database authentication
✅ Use environment variables for secrets
✅ Regular security updates

• GDPR compliance for European data protection
• SOC 2 Type II security framework alignment
• Data residency controls for regional compliance
• Export/backup capabilities for data portability

Metrics Tracking:
  - API response times
  - Database query performance
  - LLM token usage and costs
  - User engagement analytics
  - Error rates and debugging

Monitoring Stack:
  - Prometheus metrics collection
  - Grafana dashboards
  - OpenTelemetry tracing
  - Custom alerting rules

Connection Problems:

# Database connection fails
docker-compose logs mongodb
# Check if MongoDB is running and accessible

# Redis connection timeout
docker-compose restart redis
# Verify Redis configuration

Performance Issues:

# Slow API responses
# Check database indexes
poetry run python scripts/optimize-db.py

# High memory usage
# Monitor with htop or Docker stats
docker stats prompt-flow-backend

Development Environment:

# Hot reload not working
npm run dev -- --force
# Clear Vite cache

# Poetry dependency conflicts
poetry lock --no-update
poetry install

Debug Mode

# Enable debug logging
export LOG_LEVEL=DEBUG
export PYTHONPATH="${PYTHONPATH}:./backend"

# Frontend debug mode
npm run dev:debug

• UI Translation: English, Spanish, French, German, Chinese
• Prompt Templates: Localized examples and best practices
• Documentation: Multi-language API docs and guides

// Frontend i18n configuration
import { i18n } from './src/i18n';

const supportedLanguages = ['en', 'es', 'fr', 'de', 'zh'];

• Content Generation: Blog post creation workflow
• Data Analysis: CSV processing and insights generation
• Customer Support: Automated response classification
• Code Review: Pull request analysis and suggestions

# Slack integration
from prompt_flow_client import PromptFlowClient

client = PromptFlowClient(api_key="your-key")
result = client.execute_flow(
    flow_id="slack-responder",
    inputs={"message": slack_message}
)

• 🎥 Getting Started (5 min)
• 🎥 Building Your First Flow (15 min)
• 🎥 A/B Testing Setup (10 min)
• 🎥 Production Deployment (20 min)

# Kubernetes scaling configuration
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: prompt-flow-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: prompt-flow-api
  minReplicas: 3
  maxReplicas: 100
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

• Multi-tenant architecture with organization isolation
• Single Sign-On (SSO) integration (SAML, OAuth)
• Advanced analytics and usage reporting
• Priority support and SLA guarantees
• Custom integrations and professional services

# Automated migration script
python scripts/migrate_from_azure.py \
  --azure-workspace "your-workspace" \
  --target-instance "http://localhost:8000"

# Export Langflow flows
langflow export --output flows.json

# Import to Prompt Flow
poetry run python scripts/import_langflow.py flows.json

• ✨ Initial release with core features
• 🎯 Multi-database architecture
• 🧪 A/B testing framework
• 📊 Real-time execution monitoring

• 🔌 Plugin marketplace
• 👥 Collaborative editing
• 📱 Mobile app support
• 🎨 Custom themes