compose-anything/apps/langflow

Langflow

Langflow is a low-code visual framework for building AI applications. It's Python-based and agnostic to any model, API, or database, making it easy to build RAG applications, multi-agent systems, and custom AI workflows.

Features

• Visual Flow Builder: Drag-and-drop interface for building AI applications
• Multi-Model Support: Works with OpenAI, Anthropic, Google, HuggingFace, and more
• RAG Components: Built-in support for vector databases and retrieval
• Custom Components: Create your own Python components
• Agent Support: Build multi-agent systems with memory and tools
• Real-Time Monitoring: Track executions and debug flows
• API Integration: REST API for programmatic access

Quick Start

1. Copy .env.example to .env:

   cp .env.example .env
   

2. (Optional) Edit .env to customize settings:

   • Generate a secure LANGFLOW_SECRET_KEY for production
   • Set LANGFLOW_AUTO_LOGIN=false to require authentication
   • Configure superuser credentials
   • Add API keys for LLM providers

3. Start Langflow:

   docker compose up -d
   

4. Wait for services to be ready (usually takes 1-2 minutes)

5. Access Langflow UI at http://localhost:7860

6. Start building your AI application!

Default Configuration

Service	Port	Description
Langflow	7860	Web UI and API
PostgreSQL	5432	Database (internal)

Default Credentials (if authentication enabled):

• Username: langflow
• Password: langflow

Environment Variables

Key environment variables (see .env.example for full list):

Variable	Description	Default
LANGFLOW_VERSION	Langflow image version	1.1.1
LANGFLOW_PORT_OVERRIDE	Host port for UI	7860
POSTGRES_PASSWORD	Database password	langflow
LANGFLOW_AUTO_LOGIN	Auto-login (disable for auth)	true
LANGFLOW_SUPERUSER	Superuser username	langflow
LANGFLOW_SUPERUSER_PASSWORD	Superuser password	langflow
LANGFLOW_SECRET_KEY	Secret key for sessions	(empty)
LANGFLOW_COMPONENTS_PATH	Custom components directory	(empty)
LANGFLOW_LOAD_FLOWS_PATH	Auto-load flows directory	(empty)
TZ	Timezone	UTC

Resource Requirements

Minimum:

• CPU: 1 core
• RAM: 1GB
• Disk: 5GB

Recommended:

• CPU: 2+ cores
• RAM: 2GB+
• Disk: 20GB+

Volumes

• postgres_data: PostgreSQL database data
• langflow_data: Langflow configuration, flows, and logs

Using Langflow

Building Your First Flow

1. Access the UI at http://localhost:7860
2. Click "New Flow" or use a template
3. Drag components from the sidebar to the canvas
4. Connect components by dragging between ports
5. Configure component parameters
6. Click "Run" to test your flow
7. Use the API or integrate with your application

Adding LLM Providers

To use external LLM providers, configure their API keys:

1. In Langflow UI, go to Settings > Global Variables
2. Add your API keys (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)
3. Reference these variables in your flow components

Alternatively, add them to your .env file and restart:

# Example LLM API Keys (add to .env)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=...

Custom Components

To add custom components:

1. Create a directory for your components (e.g., ./custom_components)

2. Update .env:

   LANGFLOW_COMPONENTS_PATH=/app/langflow/custom_components
   

3. Mount the directory in docker-compose.yaml:

   volumes:
     - ./custom_components:/app/langflow/custom_components
   

4. Restart Langflow

Auto-Loading Flows

To automatically load flows on startup:

1. Export your flows as JSON files

2. Create a directory (e.g., ./flows)

3. Update .env:

   LANGFLOW_LOAD_FLOWS_PATH=/app/langflow/flows
   

4. Mount the directory in docker-compose.yaml:

   volumes:
     - ./flows:/app/langflow/flows
   

5. Restart Langflow

API Usage

Langflow provides a REST API for running flows programmatically.

Get Flow ID

1. Open your flow in the UI
2. The flow ID is in the URL: http://localhost:7860/flow/{flow_id}

Run Flow via API

curl -X POST http://localhost:7860/api/v1/run/{flow_id} \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": {
      "input_field": "your input value"
    }
  }'

With Authentication

If authentication is enabled, first get a token:

# Login
curl -X POST http://localhost:7860/api/v1/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "langflow",
    "password": "langflow"
  }'

# Use token in subsequent requests
curl -X POST http://localhost:7860/api/v1/run/{flow_id} \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": {
      "input_field": "your input value"
    }
  }'

Production Deployment

For production deployments:

1. Enable Authentication:

   LANGFLOW_AUTO_LOGIN=false
   LANGFLOW_SUPERUSER=admin
   LANGFLOW_SUPERUSER_PASSWORD=<strong-password>
   

2. Set Secret Key:

   # Generate a secure key
   python -c "from secrets import token_urlsafe; print(token_urlsafe(32))"
   
   # Add to .env
   LANGFLOW_SECRET_KEY=<generated-key>
   

3. Use Strong Database Password:

   POSTGRES_PASSWORD=<strong-password>
   

4. Enable SSL/TLS: Use a reverse proxy (nginx, traefik) with SSL certificates

5. Configure Resource Limits: Adjust CPU and memory limits based on your workload

6. Backup Database: Regularly backup the PostgreSQL data volume

Troubleshooting

Langflow Won't Start

• Check logs: docker compose logs langflow
• Ensure PostgreSQL is healthy: docker compose ps postgres
• Verify port 7860 is not in use

Components Not Loading

• Check custom components path is correct
• Ensure Python dependencies are installed in custom components
• Check logs for component errors

Slow Performance

• Increase resource limits in .env
• Reduce LANGFLOW_WORKERS if low on memory
• Optimize your flows (reduce unnecessary components)

Database Connection Errors

• Verify PostgreSQL is running: docker compose ps postgres
• Check database credentials in .env
• Ensure LANGFLOW_DATABASE_URL is correct

Maintenance

Backup

Backup volumes:

docker compose down
docker run --rm -v compose-anything_postgres_data:/data -v $(pwd):/backup alpine tar czf /backup/postgres-backup.tar.gz -C /data .
docker run --rm -v compose-anything_langflow_data:/data -v $(pwd):/backup alpine tar czf /backup/langflow-backup.tar.gz -C /data .
docker compose up -d

Restore

Restore from backup:

docker compose down
docker run --rm -v compose-anything_postgres_data:/data -v $(pwd):/backup alpine sh -c "cd /data && tar xzf /backup/postgres-backup.tar.gz"
docker run --rm -v compose-anything_langflow_data:/data -v $(pwd):/backup alpine sh -c "cd /data && tar xzf /backup/langflow-backup.tar.gz"
docker compose up -d

Upgrade

To upgrade Langflow:

1. Update version in .env:

   LANGFLOW_VERSION=1.2.0
   

2. Pull new image and restart:

   docker compose pull
   docker compose up -d
   

3. Check for breaking changes in release notes

Useful Commands

# View logs
docker compose logs -f langflow

# Restart Langflow
docker compose restart langflow

# Access PostgreSQL
docker compose exec postgres psql -U langflow -d langflow

# Check resource usage
docker stats

# Clean up
docker compose down -v  # WARNING: Deletes all data

References

• Official Documentation
• GitHub Repository
• Component Documentation
• API Documentation
• Community Discord

License

MIT - See LICENSE