feat: add sim & pingap

This commit is contained in:
Sun-ZhenXing
2025-12-27 11:24:44 +08:00
parent 72b36f2748
commit d536fbc995
25 changed files with 1727 additions and 483 deletions

336
apps/langflow/README.md Normal file
View File

@@ -0,0 +1,336 @@
# 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`:
```bash
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:
```bash
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:
```bash
# 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`:
```bash
LANGFLOW_COMPONENTS_PATH=/app/langflow/custom_components
```
3. Mount the directory in `docker-compose.yaml`:
```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`:
```bash
LANGFLOW_LOAD_FLOWS_PATH=/app/langflow/flows
```
4. Mount the directory in `docker-compose.yaml`:
```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
```bash
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:
```bash
# 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**:
```bash
LANGFLOW_AUTO_LOGIN=false
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD=<strong-password>
```
2. **Set Secret Key**:
```bash
# 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**:
```bash
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:
```bash
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:
```bash
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`:
```bash
LANGFLOW_VERSION=1.2.0
```
2. Pull new image and restart:
```bash
docker compose pull
docker compose up -d
```
3. Check for breaking changes in release notes
## Useful Commands
```bash
# 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](https://docs.langflow.org/)
- [GitHub Repository](https://github.com/langflow-ai/langflow)
- [Component Documentation](https://docs.langflow.org/components/)
- [API Documentation](https://docs.langflow.org/api/)
- [Community Discord](https://discord.gg/langflow)
## License
MIT - See [LICENSE](https://github.com/langflow-ai/langflow/blob/main/LICENSE)