FastAPI on Producthunt daily

n8n-workflows

Tue, 16 Sep 2025 15:28:58 +0800

Zie619/n8n-workflows

⚡ N8N Workflow Collection & Documentation

A professionally organized collection of 2,053 n8n workflows with a lightning-fast documentation system that provides instant search, analysis, and browsing capabilities.

⚠️ IMPORTANT NOTICE (Aug 14, 2025): Repository history has been rewritten due to DMCA compliance. If you have a fork or local clone, please see Issue #X for instructions on syncing your copy.

Support My Work

If you’d like to say thanks, consider buying me a coffee—your support helps me keep improving this project!

🚀 NEW: High-Performance Documentation System

Experience 100x performance improvement over traditional documentation!

Quick Start - Fast Documentation System

# Install dependencies
pip install -r requirements.txt

# Start the fast API server
python run.py

# Open in browser
http://localhost:8000

Features:

⚡ Sub-100ms response times with SQLite FTS5 search
🔍 Instant full-text search with advanced filtering
📱 Responsive design - works perfectly on mobile
🌙 Dark/light themes with system preference detection
📊 Live statistics - 365 unique integrations, 29,445 total nodes
🎯 Smart categorization by trigger type and complexity
🎯 Use case categorization by service name mapped to categories
📄 On-demand JSON viewing and download
🔗 Mermaid diagram generation for workflow visualization
🔄 Real-time workflow naming with intelligent formatting

Performance Comparison

Metric	Old System	New System	Improvement
File Size	71MB HTML	<100KB	700x smaller
Load Time	10+ seconds	<1 second	10x faster
Search	Client-side only	Full-text with FTS5	Instant
Memory Usage	~2GB RAM	<50MB RAM	40x less
Mobile Support	Poor	Excellent	Fully responsive

📂 Repository Organization

Workflow Collection

2,053 workflows with meaningful, searchable names
365 unique integrations across popular platforms
29,445 total nodes with professional categorization
Quality assurance - All workflows analyzed and categorized

Advanced Naming System ✨

Our intelligent naming system converts technical filenames into readable titles:

Before: 2051_Telegram_Webhook_Automation_Webhook.json
After: Telegram Webhook Automation
100% meaningful names with smart capitalization
Automatic integration detection from node analysis

Use Case Category ✨

The search interface includes a dropdown filter that lets you browse 2,000+ workflows by category.

The system includes an automated categorization feature that organizes workflows by service categories to make them easier to discover and filter.

How Categorization Works

Run the categorization script
1

python create_categories.py
Service Name Recognition The script analyzes each workflow JSON filename to identify recognized service names (e.g., “Twilio”, “Slack”, “Gmail”, etc.)
Category Mapping Each recognized service name is matched to its corresponding category using the definitions in context/def_categories.json. For example:
- Twilio → Communication & Messaging
- Gmail → Communication & Messaging
- Airtable → Data Processing & Analysis
- Salesforce → CRM & Sales
Search Categories Generation The script produces a search_categories.json file that contains the categorized workflow data
Filter Interface Users can then filter workflows by category in the search interface, making it easier to find workflows for specific use cases

Available Categories

The categorization system includes the following main categories:

AI Agent Development
Business Process Automation
Cloud Storage & File Management
Communication & Messaging
Creative Content & Video Automation
Creative Design Automation
CRM & Sales
Data Processing & Analysis
E-commerce & Retail
Financial & Accounting
Marketing & Advertising Automation
Project Management
Social Media Management
Technical Infrastructure & DevOps
Web Scraping & Data Extraction

Contribute Categories

You can help expand the categorization by adding more service-to-category mappings (e.g., Twilio → Communication & Messaging) in context/defs_categories.json.

Many workflow JSON files are conveniently named with the service name, often separated by underscores (_).

🛠 Usage Instructions

Option 1: Modern Fast System (Recommended)

# Clone repository
git clone <repo-url>
cd n8n-workflows

# Install Python dependencies
pip install -r requirements.txt

# Start the documentation server
python run.py

# Browse workflows at http://localhost:8000
# - Instant search across 2,053 workflows
# - Professional responsive interface
# - Real-time workflow statistics

Option 2: Development Mode

# Start with auto-reload for development
python run.py --dev

# Or specify custom host/port
python run.py --host 0.0.0.0 --port 3000

# Force database reindexing
python run.py --reindex

Import Workflows into n8n

# Use the Python importer (recommended)
python import_workflows.py

# Or manually import individual workflows:
# 1. Open your n8n Editor UI
# 2. Click menu (☰) → Import workflow
# 3. Choose any .json file from the workflows/ folder
# 4. Update credentials/webhook URLs before running

📊 Workflow Statistics

Current Collection Stats

Total Workflows: 2,053 automation workflows
Active Workflows: 215 (10.5% active rate)
Total Nodes: 29,445 (avg 14.3 nodes per workflow)
Unique Integrations: 365 different services and APIs
Database: SQLite with FTS5 full-text search

Trigger Distribution

Complex: 831 workflows (40.5%) - Multi-trigger systems
Webhook: 519 workflows (25.3%) - API-triggered automations
Manual: 477 workflows (23.2%) - User-initiated workflows
Scheduled: 226 workflows (11.0%) - Time-based executions

Complexity Analysis

Low (≤5 nodes): ~35% - Simple automations
Medium (6-15 nodes): ~45% - Standard workflows
High (16+ nodes): ~20% - Complex enterprise systems

Popular Integrations

Top services by usage frequency:

Communication: Telegram, Discord, Slack, WhatsApp
Cloud Storage: Google Drive, Google Sheets, Dropbox
Databases: PostgreSQL, MySQL, MongoDB, Airtable
AI/ML: OpenAI, Anthropic, Hugging Face
Development: HTTP Request, Webhook, GraphQL

🔍 Advanced Search Features

Smart Search Categories

Our system automatically categorizes workflows into 12 service categories:

Available Categories:

messaging: Telegram, Discord, Slack, WhatsApp, Teams
ai_ml: OpenAI, Anthropic, Hugging Face
database: PostgreSQL, MySQL, MongoDB, Redis, Airtable
email: Gmail, Mailjet, Outlook, SMTP/IMAP
cloud_storage: Google Drive, Google Docs, Dropbox, OneDrive
project_management: Jira, GitHub, GitLab, Trello, Asana
social_media: LinkedIn, Twitter/X, Facebook, Instagram
ecommerce: Shopify, Stripe, PayPal
analytics: Google Analytics, Mixpanel
calendar_tasks: Google Calendar, Cal.com, Calendly
forms: Typeform, Google Forms, Form Triggers
development: Webhook, HTTP Request, GraphQL, SSE

API Usage Examples

# Search workflows by text
curl "http://localhost:8000/api/workflows?q=telegram+automation"

# Filter by trigger type and complexity
curl "http://localhost:8000/api/workflows?trigger=Webhook&complexity=high"

# Find all messaging workflows
curl "http://localhost:8000/api/workflows/category/messaging"

# Get database statistics
curl "http://localhost:8000/api/stats"

# Browse available categories
curl "http://localhost:8000/api/categories"

🏗 Technical Architecture

Modern Stack

SQLite Database - FTS5 full-text search with 365 indexed integrations
FastAPI Backend - RESTful API with automatic OpenAPI documentation
Responsive Frontend - Modern HTML5 with embedded CSS/JavaScript
Smart Analysis - Automatic workflow categorization and naming

Key Features

Change Detection - MD5 hashing for efficient re-indexing
Background Processing - Non-blocking workflow analysis
Compressed Responses - Gzip middleware for optimal speed
Error Handling - Graceful degradation and comprehensive logging
Mobile Optimization - Touch-friendly interface design

Database Performance

-- Optimized schema for lightning-fast queries
CREATE TABLE workflows (
    id INTEGER PRIMARY KEY,
    filename TEXT UNIQUE,
    name TEXT,
    active BOOLEAN,
    trigger_type TEXT,
    complexity TEXT,
    node_count INTEGER,
    integrations TEXT,  -- JSON array of 365 unique services
    description TEXT,
    file_hash TEXT,     -- MD5 for change detection
    analyzed_at TIMESTAMP
);

-- Full-text search with ranking
CREATE VIRTUAL TABLE workflows_fts USING fts5(
    filename, name, description, integrations, tags,
    content='workflows', content_rowid='id'
);

🔧 Setup & Requirements

System Requirements

Python 3.7+ - For running the documentation system
Modern Browser - Chrome, Firefox, Safari, Edge
50MB Storage - For SQLite database and indexes
n8n Instance - For importing and running workflows

Installation

# Clone repository
git clone <repo-url>
cd n8n-workflows

# Install dependencies
pip install -r requirements.txt

# Start documentation server
python run.py

# Access at http://localhost:8000

Development Setup

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # Linux/Mac
# or .venv\Scripts\activate  # Windows

# Install dependencies
pip install -r requirements.txt

# Run with auto-reload for development
python api_server.py --reload

# Force database reindexing
python workflow_db.py --index --force

📋 Naming Convention

Intelligent Formatting System

Our system automatically converts technical filenames to user-friendly names:

# Automatic transformations:
2051_Telegram_Webhook_Automation_Webhook.json → "Telegram Webhook Automation"
0250_HTTP_Discord_Import_Scheduled.json → "HTTP Discord Import Scheduled"  
0966_OpenAI_Data_Processing_Manual.json → "OpenAI Data Processing Manual"

Technical Format

`1`	`[ID]_[Service1]_[Service2]_[Purpose]_[Trigger].json`

Smart Capitalization Rules

HTTP → HTTP (not Http)
API → API (not Api)
webhook → Webhook
automation → Automation
scheduled → Scheduled

🚀 API Documentation

Core Endpoints

GET / - Main workflow browser interface
GET /api/stats - Database statistics and metrics
GET /api/workflows - Search with filters and pagination
GET /api/workflows/{filename} - Detailed workflow information
GET /api/workflows/{filename}/download - Download workflow JSON
GET /api/workflows/{filename}/diagram - Generate Mermaid diagram

Advanced Search

GET /api/workflows/category/{category} - Search by service category
GET /api/categories - List all available categories
GET /api/integrations - Get integration statistics
POST /api/reindex - Trigger background reindexing

Response Examples

// GET /api/stats
{
  "total": 2053,
  "active": 215,
  "inactive": 1838,
  "triggers": {
    "Complex": 831,
    "Webhook": 519,
    "Manual": 477,
    "Scheduled": 226
  },
  "total_nodes": 29445,
  "unique_integrations": 365
}

🤝 Contributing

Adding New Workflows

Export workflow as JSON from n8n
Name descriptively following the established pattern
Add to workflows/ directory
Remove sensitive data (credentials, personal URLs)
Run reindexing to update the database

Quality Standards

✅ Workflow must be functional and tested
✅ Remove all credentials and sensitive data
✅ Follow naming convention for consistency
✅ Verify compatibility with recent n8n versions
✅ Include meaningful description or comments

⚠️ Important Notes

Security & Privacy

Review before use - All workflows shared as-is for educational purposes
Update credentials - Replace API keys, tokens, and webhooks
Test safely - Verify in development environment first
Check permissions - Ensure proper access rights for integrations

Compatibility

n8n Version - Compatible with n8n 1.0+ (most workflows)
Community Nodes - Some workflows may require additional node installations
API Changes - External services may have updated their APIs since creation
Dependencies - Verify required integrations before importing

📚 Resources & References

Workflow Sources

This comprehensive collection includes workflows from:

Official n8n.io - Documentation and community examples
GitHub repositories - Open source community contributions
Blog posts & tutorials - Real-world automation patterns
User submissions - Tested and verified workflows
Enterprise use cases - Business process automations

Learn More

n8n Documentation - Official documentation
n8n Community - Community forum and support
Workflow Templates - Official template library
Integration Docs - Service-specific guides

🏆 Project Achievements

Repository Transformation

2,053 workflows professionally organized and named
365 unique integrations automatically detected and categorized
100% meaningful names (improved from basic filename patterns)
Zero data loss during intelligent renaming process
Advanced search with 12 service categories

Performance Revolution

Sub-100ms search with SQLite FTS5 full-text indexing
Instant filtering across 29,445 workflow nodes
Mobile-optimized responsive design for all devices
Real-time statistics with live database queries
Professional interface with modern UX principles

System Reliability

Robust error handling with graceful degradation
Change detection for efficient database updates
Background processing for non-blocking operations
Comprehensive logging for debugging and monitoring
Production-ready with proper middleware and security

This repository represents the most comprehensive and well-organized collection of n8n workflows available, featuring cutting-edge search technology and professional documentation that makes workflow discovery and usage a delightful experience.

🎯 Perfect for: Developers, automation engineers, business analysts, and anyone looking to streamline their workflows with proven n8n automations.

中文

ROMA

Sun, 14 Sep 2025 15:24:50 +0800

sentient-agi/ROMA

ROMA: Recursive Open Meta-Agents

Building hierarchical high-performance multi-agent systems made easy! (Beta)

Technical Blog • Paper (Coming soon) • Build Agents for $$$

📖 Documentation

🚀 Introduction - Understand the vision and architecture behind ROMA
📦 Setup - Detailed configuration options and environment setup
🤖 Agents Guide - Learn how to create and customize your own agents
⚙️ Configuration - Detailed configuration options and environment setup
🗺️ Roadmap - See what’s coming next for ROMA

🎯 What is ROMA?

ROMA is a meta-agent framework that uses recursive hierarchical structures to solve complex problems. By breaking down tasks into parallelizable components, ROMA enables agents to tackle sophisticated reasoning challenges while maintaining transparency that makes context-engineering and iteration straightforward. The framework offers parallel problem solving where agents work simultaneously on different parts of complex tasks, transparent development with a clear structure for easy debugging, and proven performance demonstrated through our search agent’s strong benchmark results. We’ve shown the framework’s effectiveness, but this is just the beginning. As an open-source and extensible platform, ROMA is designed for community-driven development, allowing you to build and customize agents for your specific needs while benefiting from the collective improvements of the community.

🏗️ How It Works

ROMA framework processes tasks through a recursive plan–execute loop:

def solve(task):
    if is_atomic(task):                 # Step 1: Atomizer
        return execute(task)            # Step 2: Executor
    else:
        subtasks = plan(task)           # Step 2: Planner
        results = []
        for subtask in subtasks:
            results.append(solve(subtask))  # Recursive call
        return aggregate(results)       # Step 3: Aggregator

# Entry point:
answer = solve(initial_request)

Atomizer – Decides whether a request is atomic (directly executable) or requires planning.
Planner – If planning is needed, the task is broken into smaller subtasks. Each subtask is fed back into the Atomizer, making the process recursive.
Executors – Handle atomic tasks. Executors can be LLMs, APIs, or even other agents — as long as they implement an agent.execute() interface.
Aggregator – Collects and integrates results from subtasks. Importantly, the Aggregator produces the answer to the original parent task, not just raw child outputs.

📐 Information Flow

Top-down: Tasks are decomposed into subtasks recursively.
Bottom-up: Subtask results are aggregated upwards into solutions for parent tasks.
Left-to-right: If a subtask depends on the output of a previous one, it waits until that subtask completes before execution.

This structure makes the system flexible, recursive, and dependency-aware — capable of decomposing complex problems into smaller steps while ensuring results are integrated coherently.

Click to view the system flow diagram

  flowchart TB
    A[Your Request] --> B{Atomizer}
    B -->|Plan Needed| C[Planner]
    B -->|Atomic Task| D[Executor]

    %% Planner spawns subtasks
    C --> E[Subtasks]
    E --> G[Aggregator]

    %% Recursion
    E -.-> B  

    %% Execution + Aggregation
    D --> F[Final Result]
    G --> F

    style A fill:#e1f5fe
    style F fill:#c8e6c9
    style B fill:#fff3e0
    style C fill:#ffe0b2
    style D fill:#d1c4e9
    style G fill:#c5cae9

🚀 30-Second Quick Start

git clone https://github.com/sentient-agi/ROMA.git
cd ROMA

# Run the automated setup
./setup.sh

Choose between:

Docker Setup (Recommended) - One-command setup with isolation
Native Setup - Direct installation for development

🛠️ Technical Stack

Framework: Built on AgnoAgents
Backend: Python 3.12+ with FastAPI/Flask
Frontend: React + TypeScript with real-time WebSocket
LLM Support: Any provider via LiteLLM
Data Persistence: Enterprise S3 mounting with security validation
- 🔒 goofys FUSE mounting for zero-latency file access
- 🛡️ Path injection protection with comprehensive validation
- 🔐 AWS credentials verification before operations
- 📁 Dynamic Docker Compose with secure volume mounting
Code Execution: E2B sandboxes with unified S3 integration
Security: Production-grade validation and error handling
Features: Multi-modal, tools, MCP, hooks, caching

📦 Installation Options

Quick Start (Recommended)

# Main setup (choose Docker or Native)
./setup.sh

# Optional: Setup E2B sandbox integration
./setup.sh --e2b

# Test E2B integration  
./setup.sh --test-e2b

Command Line Options

./setup.sh --docker     # Run Docker setup directly
./setup.sh --docker-from-scratch  # Rebuild Docker images/containers from scratch (down -v, no cache)
./setup.sh --native     # Run native setup directly (macOS/Ubuntu/Debian)
./setup.sh --e2b        # Setup E2B template (requires E2B_API_KEY + AWS creds)
./setup.sh --test-e2b   # Test E2B template integration
./setup.sh --help       # Show all available options

Manual Installation

See setup docs for detailed instructions.

🏗️ Optional: E2B Sandbox Integration

For secure code execution capabilities, optionally set up E2B sandboxes:

# After main setup, configure E2B (requires E2B_API_KEY and AWS credentials in .env)
./setup.sh --e2b

# Test E2B integration
./setup.sh --test-e2b

E2B Features:

🔒 Secure Code Execution - Run untrusted code in isolated sandboxes
☁️ S3 Integration - Automatic data sync between local and sandbox environments
🚀 goofys Mounting - High-performance S3 filesystem mounting
🔧 AWS Credentials - Passed securely via Docker build arguments

🤖 Pre-built Agents

Note: These agents are demonstrations built using ROMA’s framework through simple vibe-prompting and minimal manual tuning. They showcase how easily you can create high-performance agents with ROMA, rather than being production-final solutions. Our mission is to empower the community to build, share, and get rewarded for creating innovative agent recipes and use-cases.

ROMA comes with example agents that demonstrate the framework’s capabilities:

🔍 General Task Solver

A versatile agent powered by ChatGPT Search Preview for handling diverse tasks:

Intelligent Search: Leverages OpenAI’s latest search capabilities for real-time information
Flexible Planning: Adapts task decomposition based on query complexity
Multi-Domain: Handles everything from technical questions to creative projects
Quick Prototyping: Perfect for testing ROMA’s capabilities without domain-specific setup

Perfect for: General research, fact-checking, exploratory analysis, quick information gathering

🔬 Deep Research Agent

A comprehensive research system that breaks down complex research questions into manageable sub-tasks:

Smart Task Decomposition: Automatically splits research topics into search, analysis, and synthesis phases
Parallel Information Gathering: Executes multiple searches simultaneously for faster results
Multi-Source Integration: Combines results from web search, Wikipedia, and specialized APIs
Intelligent Synthesis: Aggregates findings into coherent, well-structured reports

Perfect for: Academic research, market analysis, competitive intelligence, technical documentation

💹 Crypto Analytics Agent

Specialized financial analysis agent with deep blockchain and DeFi expertise:

Real-Time Market Data: Integrates with Binance, CoinGecko, and DefiLlama APIs
On-Chain Analytics: Access to Arkham Intelligence for wallet tracking and token flows
Technical Analysis: Advanced charting with OHLC data and market indicators
DeFi Metrics: TVL tracking, yield analysis, protocol comparisons
Secure Execution: Runs analysis in E2B sandboxes with data persistence

Perfect for: Token research, portfolio analysis, DeFi protocol evaluation, market trend analysis

All three agents demonstrate ROMA’s recursive architecture in action, showing how complex queries that would overwhelm single-pass systems can be elegantly decomposed and solved. They serve as templates and inspiration for building your own specialized agents.

Your First Agent in 5 Minutes

`1`	`./setup.sh # Automated setup with Docker or native installation`

Access all the pre-defined agents through the frontend on localhost:3000 after setting up the backend on localhost:5000. Please checkout Setup and the Agents guide to get started!

# Your first agent in 3 lines
from sentientresearchagent import SentientAgent

agent = SentientAgent.create()
result = await agent.run("Create a podcast about AI safety")

📊 Benchmarks

We evaluate our simple implementation of a search system using ROMA, called ROMA-Search across three benchmarks: SEAL-0, FRAMES, and SimpleQA.
Below are the performance graphs for each benchmark.

SEAL-0

SealQA is a new challenging benchmark for evaluating Search-Augmented Language models on fact-seeking questions where web search yields conflicting, noisy, or unhelpful results.

FRAMES

View full results

A comprehensive evaluation dataset designed to test the capabilities of Retrieval-Augmented Generation (RAG) systems across factuality, retrieval accuracy, and reasoning.

SimpleQA

View full results

Factuality benchmark that measures the ability for language models to answer short, fact-seeking questions.

✨ Features

🔄 Recursive Task Decomposition

Automatically breaks down complex tasks into manageable subtasks with intelligent dependency management. Runs independent sub-tasks in parallel.

🤖 Agent Agnostic

Works with any provider (OpenAI, Anthropic, Google, local models) through unified interface, as long as it has an agent.run() command, then you can use it!

🔍 Complete Transparency

Stage tracing shows exactly what happens at each step - debug and optimize with full visibility

🔌 Connect Any Tool

Seamlessly integrate external tools and protocols with configurable intervention points. Already includes production-grade connectors such as E2B, file-read-write, and more.

🙏 Acknowledgments

This framework would not have been possible if it wasn’t for these amazing open-source contributions!

Inspired by the hierarchical planning approach described in “Beyond Outlining: Heterogeneous Recursive Planning” by Xiong et al.
Pydantic - Data validation using Python type annotations
Agno - Framework for building AI agents
E2B - Cloud runtime for AI agents

📚 Citation

If you use the ROMA repo in your research, please cite:

@software{al_zubi_2025_17052592,
  author       = {Al-Zubi, Salah and
                  Nama, Baran and
                  Kaz, Arda and
                  Oh, Sewoong},
  title        = {SentientResearchAgent: A Hierarchical AI Agent
                   Framework for Research and Analysis
                  },
  month        = sep,
  year         = 2025,
  publisher    = {Zenodo},
  version      = {ROMA},
  doi          = {10.5281/zenodo.17052592},
  url          = {https://doi.org/10.5281/zenodo.17052592},
  swhid        = {swh:1:dir:69cd1552103e0333dd0c39fc4f53cb03196017ce
                   ;origin=https://doi.org/10.5281/zenodo.17052591;vi
                   sit=swh:1:snp:f50bf99634f9876adb80c027361aec9dff97
                   3433;anchor=swh:1:rel:afa7caa843ce1279f5b4b29b5d3d
                   5e3fe85edc95;path=salzubi401-ROMA-b31c382
                  },
}

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

fastapi_mcp

Sat, 16 Aug 2025 15:26:52 +0800

tadata-org/fastapi_mcp

Built by Tadata

FastAPI-MCP

Expose your FastAPI endpoints as Model Context Protocol (MCP) tools, with Auth!

Features

Authentication built in, using your existing FastAPI dependencies!
FastAPI-native: Not just another OpenAPI -> MCP converter
Zero/Minimal configuration required - just point it at your FastAPI app and it works
Preserving schemas of your request models and response models
Preserve documentation of all your endpoints, just as it is in Swagger
Flexible deployment - Mount your MCP server to the same app, or deploy separately
ASGI transport - Uses FastAPI’s ASGI interface directly for efficient communication

Hosted Solution

If you prefer a managed hosted solution check out tadata.com.

Installation

We recommend using uv, a fast Python package installer:

`1`	`uv add fastapi-mcp`

Alternatively, you can install with pip:

`1`	`pip install fastapi-mcp`

Basic Usage

The simplest way to use FastAPI-MCP is to add an MCP server directly to your FastAPI application:

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI()

mcp = FastApiMCP(app)

# Mount the MCP server directly to your FastAPI app
mcp.mount()

That’s it! Your auto-generated MCP server is now available at https://app.base.url/mcp.

Documentation, Examples and Advanced Usage

FastAPI-MCP provides comprehensive documentation. Additionaly, check out the examples directory for code samples demonstrating these features in action.

FastAPI-first Approach

FastAPI-MCP is designed as a native extension of FastAPI, not just a converter that generates MCP tools from your API. This approach offers several key advantages:

Native dependencies: Secure your MCP endpoints using familiar FastAPI Depends() for authentication and authorization
ASGI transport: Communicates directly with your FastAPI app using its ASGI interface, eliminating the need for HTTP calls from the MCP to your API
Unified infrastructure: Your FastAPI app doesn’t need to run separately from the MCP server (though separate deployment is also supported)

This design philosophy ensures minimum friction when adding MCP capabilities to your existing FastAPI services.

Development and Contributing

Thank you for considering contributing to FastAPI-MCP! We encourage the community to post Issues and create Pull Requests.

Before you get started, please see our Contribution Guide.

Community

Join MCParty Slack community to connect with other MCP enthusiasts, ask questions, and share your experiences with FastAPI-MCP.

Requirements

Python 3.10+ (Recommended 3.12)
uv

License

suna

Tue, 24 Jun 2025 15:30:37 +0800

kortix-ai/suna

Suna - Open Source Generalist AI Agent

(that acts on your behalf)

Suna is a fully open source AI assistant that helps you accomplish real-world tasks with ease. Through natural conversation, Suna becomes your digital companion for research, data analysis, and everyday challenges—combining powerful capabilities with an intuitive interface that understands what you need and delivers results.

Suna’s powerful toolkit includes seamless browser automation to navigate the web and extract data, file management for document creation and editing, web crawling and extended search capabilities, command-line execution for system tasks, website deployment, and integration with various APIs and services. These capabilities work together harmoniously, allowing Suna to solve your complex problems and automate workflows through simple conversations!

[

Project Architecture

Suna consists of four main components:

Backend API

Python/FastAPI service that handles REST endpoints, thread management, and LLM integration with Anthropic, and others via LiteLLM.

Frontend

Next.js/React application providing a responsive UI with chat interface, dashboard, etc.

Agent Docker

Isolated execution environment for every agent - with browser automation, code interpreter, file system access, tool integration, and security features.

Supabase Database

Handles data persistence with authentication, user management, conversation history, file storage, agent state, analytics, and real-time subscriptions.

Use Cases

Competitor Analysis (Watch) - “Analyze the market for my next company in the healthcare industry, located in the UK. Give me the major players, their market size, strengths, and weaknesses, and add their website URLs. Once done, generate a PDF report.”
VC List (Watch) - “Give me the list of the most important VC Funds in the United States based on Assets Under Management. Give me website URLs, and if possible an email to reach them out.”
Looking for Candidates (Watch) - “Go on LinkedIn, and find me 10 profiles available - they are not working right now - for a junior software engineer position, who are located in Munich, Germany. They should have at least one bachelor’s degree in Computer Science or anything related to it, and 1-year of experience in any field/role.”
Planning Company Trip (Watch) - “Generate me a route plan for my company. We should go to California. We’ll be in 8 people. Compose the trip from the departure (Paris, France) to the activities we can do considering that the trip will be 7 days long - departure on the 21st of Apr 2025. Check the weather forecast and temperature for the upcoming days, and based on that, you can plan our activities (outdoor vs indoor).”
Working on Excel (Watch) - “My company asked me to set up an Excel spreadsheet with all the information about Italian lottery games (Lotto, 10eLotto, and Million Day). Based on that, generate and send me a spreadsheet with all the basic information (public ones).”
Automate Event Speaker Prospecting (Watch) - “Find 20 AI ethics speakers from Europe who’ve spoken at conferences in the past year. Scrapes conference sites, cross-references LinkedIn and YouTube, and outputs contact info + talk summaries.”
Summarize and Cross-Reference Scientific Papers (Watch) - “Research and compare scientific papers talking about Alcohol effects on our bodies during the last 5 years. Generate a report about the most important scientific papers talking about the topic I wrote before.”
Research + First Contact Draft (Watch) - “Research my potential customers (B2B) on LinkedIn. They should be in the clean tech industry. Find their websites and their email addresses. After that, based on the company profile, generate a personalized first contact email where I present my company which is offering consulting services to cleantech companies to maximize their profits and reduce their costs.”
SEO Analysis (Watch) - “Based on my website suna.so, generate an SEO report analysis, find top-ranking pages by keyword clusters, and identify topics I’m missing.”
Generate a Personal Trip (Watch) - “Generate a personal trip to London, with departure from Bangkok on the 1st of May. The trip will last 10 days. Find an accommodation in the center of London, with a rating on Google reviews of at least 4.5. Find me interesting outdoor activities to do during the journey. Generate a detailed itinerary plan.”
Recently Funded Startups (Watch) - “Go on Crunchbase, Dealroom, and TechCrunch, filter by Series A funding rounds in the SaaS Finance Space, and build a report with company data, founders, and contact info for outbound sales.”
Scrape Forum Discussions (Watch) - “I need to find the best beauty centers in Rome, but I want to find them by using open forums that speak about this topic. Go on Google, and scrape the forums by looking for beauty center discussions located in Rome. Then generate a list of 5 beauty centers with the best comments about them.”

Self-Hosting

Suna can be self-hosted on your own infrastructure using our comprehensive setup wizard. For a complete guide to self-hosting Suna, please refer to our Self-Hosting Guide.

The setup process includes:

Setting up a Supabase project for database and authentication
Configuring Redis for caching and session management
Setting up Daytona for secure agent execution
Integrating with LLM providers (Anthropic, OpenAI, OpenRouter, etc.)
Configuring web search and scraping capabilities (Tavily, Firecrawl)
Setting up QStash for background job processing and workflows
Configuring webhook handling for automated tasks
Optional integrations (RapidAPI, Smithery for custom agents)

Quick Start

Clone the repository:

1
2

git clone https://github.com/kortix-ai/suna.git
cd suna

Run the setup wizard:

`1`	`python setup.py`

The wizard will guide you through 14 steps with progress saving, so you can resume if interrupted.

Start or stop the containers:

`1`	`python start.py`

Manual Setup

See the Self-Hosting Guide for detailed manual setup instructions.

The wizard will guide you through all necessary steps to get your Suna instance up and running. For detailed instructions, troubleshooting tips, and advanced configuration options, see the Self-Hosting Guide.

Contributing

We welcome contributions from the community! Please see our Contributing Guide for more details.

Acknowledgements

Main Contributors

Technologies

Daytona - Secure agent execution environment
Supabase - Database and authentication
Playwright - Browser automation
OpenAI - LLM provider
Anthropic - LLM provider
Tavily - Search capabilities
Firecrawl - Web scraping capabilities
QStash - Background job processing and workflows
RapidAPI - API services
Smithery - Custom agent development

License

Kortix Suna is licensed under the Apache License, Version 2.0. See LICENSE for the full license text.

gitdiagram

Thu, 15 May 2025 15:30:17 +0800

ahmedkhaleel2004/gitdiagram

GitDiagram

Turn any GitHub repository into an interactive diagram for visualization in seconds.

You can also replace hub with diagram in any Github URL to access its diagram.

🚀 Features

👀 Instant Visualization: Convert any GitHub repository structure into a system design / architecture diagram
🎨 Interactivity: Click on components to navigate directly to source files and relevant directories
⚡ Fast Generation: Powered by OpenAI o4-mini for quick and accurate diagrams
🔄 Customization: Modify and regenerate diagrams with custom instructions
🌐 API Access: Public API available for integration (WIP)

⚙️ Tech Stack

Frontend: Next.js, TypeScript, Tailwind CSS, ShadCN
Backend: FastAPI, Python, Server Actions
Database: PostgreSQL (with Drizzle ORM)
AI: OpenAI o4-mini
Deployment: Vercel (Frontend), EC2 (Backend)
CI/CD: GitHub Actions
Analytics: PostHog, Api-Analytics

🤔 About

I created this because I wanted to contribute to open-source projects but quickly realized their codebases are too massive for me to dig through manually, so this helps me get started - but it’s definitely got many more use cases!

Given any public (or private!) GitHub repository it generates diagrams in Mermaid.js with OpenAI’s o4-mini! (Previously Claude 3.5 Sonnet)

I extract information from the file tree and README for details and interactivity (you can click components to be taken to relevant files and directories)

Most of what you might call the “processing” of this app is done with prompt engineering - see /backend/app/prompts.py. This basically extracts and pipelines data and analysis for a larger action workflow, ending in the diagram code.

🔒 How to diagram private repositories

You can simply click on “Private Repos” in the header and follow the instructions by providing a GitHub personal access token with the repo scope.

You can also self-host this app locally (backend separated as well!) with the steps below.

🛠️ Self-hosting / Local Development

Clone the repository

1
2

git clone https://github.com/ahmedkhaleel2004/gitdiagram.git
cd gitdiagram

Install dependencies

pnpm i

Set up environment variables (create .env)

`1`	`cp .env.example .env`

Then edit the .env file with your Anthropic API key and optional GitHub personal access token.

Run backend

`1`	`docker-compose up --build -d`

Logs available at docker-compose logs -f The FastAPI server will be available at localhost:8000

Start local database

1
2

chmod +x start-database.sh
./start-database.sh

When prompted to generate a random password, input yes. The Postgres database will start in a container at localhost:5432

Initialize the database schema

`1`	`pnpm db:push`

You can view and interact with the database using pnpm db:studio

Run Frontend

`1`	`pnpm dev`

You can now access the website at localhost:3000 and edit the rate limits defined in backend/app/routers/generate.py in the generate function decorator.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Acknowledgements

Shoutout to Romain Courtois’s Gitingest for inspiration and styling

📈 Rate Limits

I am currently hosting it for free with no rate limits though this is somewhat likely to change in the future.

🤔 Future Steps

Implement font-awesome icons in diagram
Implement an embedded feature like star-history.com but for diagrams. The diagram could also be updated progressively as commits are made.

bracket

Thu, 08 May 2025 15:29:33 +0800

evroon/bracket

Demo · Documentation · Quickstart · GitHub · Releases

Tournament system meant to be easy to use. Bracket is written in async Python (with FastAPI) and Next.js as frontend using the Mantine library.

It has the following features:

Supports single elimination, round-robin and swiss formats.
Build your tournament structure with multiple stages that can have multiple groups/brackets in them.
Drag-and-drop matches to different courts or reschedule them to another start time.
Various dashboard pages are available that can be presented to the public, customized with a logo.
Create/update teams, and add players to teams.
Create multiple clubs, with multiple tournaments per club.
Swiss tournaments can be handled dynamically, with automatic scheduling of matches.

Explore the Bracket docs ▶

Live Demo

A demo is available for free at https://www.bracketapp.nl/demo. The demo lasts for 30 minutes, after which your data will de deleted.

Quickstart

To quickly run bracket to see how it works, clone it and run docker compose up:

1
2
3

git clone git@github.com:evroon/bracket.git
cd bracket
sudo docker compose up -d

This will start the backend and frontend of Bracket, as well as a postgres instance. You should now be able to view bracket at http://localhost:3000. You can log in with the following credentials:

Username: test@example.org
Password: aeGhoe1ahng2Aezai0Dei6Aih6dieHoo.

To insert dummy rows into the database, run:

`1`	`sudo docker exec bracket-backend pipenv run ./cli.py create-dev-db`

Usage

Read the usage guide for how to organize a tournament in Bracket from start to finish.

Configuration

Read the configuration docs for how to configure Bracket.

Bracket’s backend is configured using .env files (prod.env for production, dev.env for development etc.). But you can also configure Bracket using environment variables directly, for example by specifying them in the docker-compose.yml.

The frontend doesn’t can be configured by environment variables as well, as well as .env files using Next.js’ way of loading environment variables.

Running Bracket in production

Read the deployment docs for how to deploy Bracket and run it in production.

Bracket can be run in Docker or by itself (using pipenv and yarn).

Development setup

Read the development docs for how to run Bracket for development.

Prerequisites are yarn, postgresql and pipenv to run the frontend, database and backend.

Translations

Based on your browser settings, your language should be automatically detected and loaded. For now, there’s no manual way of choosing a different language.

Supported Languages

To add/refine translations, Crowdin is used. See the docs for more information.

More screenshots

Help

If you’re having trouble getting Bracket up and running, or have a question about usage or configuration, feel free to ask. The best place to do this is by creating a Discussion.

Supporting Bracket

If you’re using Bracket and would like to help support its development, that would be greatly appreciated!

Several areas that we need a bit of help with at the moment are:

⭐ Star Bracket on GitHub
🌐 Translating: Help make Bracket available to non-native English speakers by adding your language (via crowdin)
📣 Spread the word by sharing Bracket to help new users discover it
🖥️ Submit a PR to add a new feature, fix a bug, extend/update the docs or something else

See the contribution docs for more information on how to contribute

Contributors

_{Erik Vroon}	_Null	_BachErik	_{Danny Piper}	_SevicheCC	_{Nicolas Vanheuverzwijn}
_IzStriker	_{Max Ricketts-Uy}	_{Raphael Le Goaller}

License

Bracket is licensed under AGPL-v3.0.

Please note that any contributions also fall under this license.

See LICENSE