| 0 |
| Ecosystem | 1 | 0 |
| Match Graph | 0 | 0 |
| Pricing | Free | Free |
| Capabilities | 13 decomposed | 9 decomposed |
| Times Matched | 0 | 0 |
Provides 100+ production-ready agent implementations across three primary frameworks (Agno, LangChain/LangGraph, and native Python) organized by complexity tier (starter, advanced single-agent, multi-agent). Each implementation includes complete dependency specifications, environment configuration templates, and runnable entry points, allowing developers to clone and immediately execute agents without framework-specific boilerplate. The repository uses a tiered complexity model where starter agents demonstrate basic tool-calling patterns, advanced agents implement planner-executor architectures with state management, and multi-agent systems showcase coordination via message passing or shared context.
Unique: Organizes 100+ implementations across three distinct frameworks (Agno, LangChain/LangGraph, native) with explicit complexity tiers (starter/advanced/expert) and domain-specific examples (finance, travel, research), enabling side-by-side framework comparison and progressive learning paths. Most agent repositories focus on a single framework; this one treats framework diversity as a feature.
vs alternatives: Broader framework coverage and clearer complexity progression than single-framework tutorials; more production-focused than academic agent papers but less opinionated than framework-specific docs
Implements 8+ distinct RAG architectures (basic retrieval, corrective RAG, hybrid retrieval, database routing, agentic RAG, autonomous RAG, RAG with reasoning) with working code for each pattern. Each implementation demonstrates a specific retrieval strategy: basic RAG uses vector similarity search, corrective RAG adds a grading step to filter irrelevant chunks, hybrid RAG combines vector and keyword search, database routing uses an LLM to select which database to query, and agentic RAG treats retrieval as a tool the agent can invoke iteratively. Implementations support multiple vector databases (Pinecone, Weaviate, Chroma, FAISS) and document sources (PDFs, web pages, databases, code repositories).
Unique: Provides 8+ distinct RAG patterns (basic, corrective, hybrid, database routing, agentic, autonomous, reasoning-enhanced) with working implementations for each, allowing developers to compare trade-offs between retrieval quality and latency. Most RAG tutorials show only basic vector search; this library treats RAG as a design space with multiple valid solutions.
vs alternatives: More comprehensive RAG pattern coverage than LangChain's built-in RAG examples; more practical than academic RAG papers with runnable code for each pattern
Implements specialized agents for financial analysis and investment decisions that integrate real-time market data, financial APIs, and domain-specific reasoning. The investment agent can fetch stock prices, analyze financial statements, calculate metrics (P/E ratio, dividend yield), and provide investment recommendations. Integration with financial data providers (Alpha Vantage, Finnhub, or similar) enables real-time market data access. The agent uses domain-specific prompts and reasoning patterns for financial analysis, handles numerical precision and currency conversions, and provides citations to data sources. Examples include portfolio analysis agents, stock recommendation agents, and market trend analysis agents.
Unique: Provides investment agent implementations with real-time market data integration, financial metric calculations, and domain-specific reasoning patterns. Demonstrates how to handle numerical precision, currency conversions, and financial data sources. Most agent tutorials are generic; this library includes domain-specific agents for finance.
vs alternatives: More specialized than generic agents but less comprehensive than dedicated financial analysis platforms; useful for prototyping financial agents
Implements agents that can browse the web, scrape content, and extract information from dynamic websites using browser automation (Selenium, Playwright, or Puppeteer). The web scraping agent can navigate websites, interact with forms and buttons, wait for dynamic content to load, and extract structured data. Integration with agent frameworks allows the agent to decide what to scrape, how to navigate, and how to extract information based on user requests. Examples include competitive intelligence agents that scrape competitor websites, price monitoring agents that track product prices, and content aggregation agents that gather information from multiple sources. The agent handles JavaScript-heavy sites and can wait for content to load before extraction.
Unique: Provides web scraping agent implementations with browser automation, dynamic content handling, and integration with agent frameworks. Demonstrates how agents can decide what to scrape and how to navigate websites. Most agent tutorials don't include web scraping; this library treats it as a legitimate agent capability with appropriate caveats.
vs alternatives: More practical than generic scraping tutorials; enables agent-driven scraping but with significant latency and resource trade-offs vs direct HTTP scraping
Implements advanced RAG patterns that improve retrieval quality beyond basic vector similarity search. Corrective RAG adds a grading step where an LLM evaluates whether retrieved documents are relevant to the query; if not, the system reformulates the query and retrieves again. Hybrid RAG combines multiple retrieval strategies (vector similarity, keyword search, semantic search) and ranks results by combining scores from different methods. Implementations demonstrate how to define relevance criteria, implement grading logic, and combine retrieval scores. The corrective approach trades latency for quality (additional LLM calls), while hybrid approaches balance different retrieval strengths.
Unique: Provides implementations of corrective RAG (with relevance grading and query reformulation) and hybrid RAG (combining vector and keyword search) with explicit trade-offs between quality and latency. Demonstrates how to define and implement relevance criteria. Most RAG tutorials show only basic vector search; this library treats quality improvement as a design pattern.
vs alternatives: More sophisticated than basic RAG but with documented latency costs; more practical than academic RAG papers with working code
Demonstrates MCP protocol integration for agents that need to interact with external systems (GitHub, Notion, browsers, file systems) through standardized tool schemas. Implementations show how to define MCP tool specifications (input schemas, descriptions), bind them to agent frameworks (Agno, LangChain), and handle tool execution with error recovery. The repository includes examples of travel planning agents using MCP for flight/hotel APIs, GitHub agents using MCP for repository operations, and browser automation agents using MCP for web scraping, all following the MCP specification for tool discovery and invocation.
Unique: Provides working MCP implementations for diverse use cases (travel planning, GitHub operations, browser automation, Notion integration) with explicit tool schema definitions and error handling patterns. Demonstrates how MCP standardizes tool discovery and invocation across different external systems, reducing boilerplate compared to custom API wrappers.
vs alternatives: More comprehensive MCP examples than official MCP documentation; more standardized than custom tool-calling implementations but less mature than framework-specific tool ecosystems
Implements multi-agent systems where specialized agents (e.g., SEO auditor, content writer, technical reviewer) coordinate via message passing or shared state to solve complex tasks. Examples include an SEO audit team where one agent crawls websites, another analyzes content, and a third generates recommendations; a home renovation agent where one agent gathers requirements, another estimates costs, and a third creates project plans. Coordination patterns include sequential task handoff (agent A completes, passes results to agent B), parallel execution with result aggregation, and hierarchical delegation (manager agent assigns tasks to worker agents). Implementations use either explicit message queues or shared context objects to pass information between agents.
Unique: Provides concrete multi-agent examples (SEO audit team, home renovation agent) with explicit coordination patterns (message passing, shared context, hierarchical delegation) and implementation code. Most agent tutorials focus on single agents; this library treats multi-agent coordination as a first-class pattern with multiple architectural approaches.
vs alternatives: More practical multi-agent examples than academic papers; more detailed than framework docs but less opinionated than specialized multi-agent frameworks like AutoGen
Implements research agents that decompose complex research queries into sub-questions, search the web for relevant information, synthesize findings, and iteratively refine results. The research agent uses a planner-executor pattern: a planner LLM breaks down 'research X' into specific search queries, an executor searches the web and retrieves documents, and a synthesizer combines results into a coherent report. Integration with Google Gemini Interactions API enables real-time web search within agent reasoning loops. The agent can iterate — if initial results are insufficient, it generates follow-up queries and searches again. Outputs include structured research reports with source citations and confidence scores.
Unique: Combines planner-executor-synthesizer architecture with iterative refinement and real-time web search via Gemini Interactions API, enabling agents to conduct research beyond their training data. Most research agents use static RAG; this implementation treats web search as a first-class agent capability with iterative improvement.
vs alternatives: More sophisticated than basic web search agents; tightly integrated with Gemini's native search capabilities but less portable than framework-agnostic approaches
+5 more capabilities
Executes SQL queries against Supabase PostgreSQL instances through the Model Context Protocol, translating natural language or structured query requests into parameterized SQL statements. Uses MCP's tool-calling interface to expose database operations as callable functions with schema validation, enabling LLM agents to perform CRUD operations, joins, and aggregations with automatic connection pooling and credential management through Supabase client SDK.
Unique: Exposes Supabase PostgreSQL as MCP tools with automatic credential injection from Supabase client SDK, eliminating manual connection string management and enabling seamless LLM-to-database queries within Claude or compatible agents
vs alternatives: Tighter integration than generic SQL MCP servers because it leverages Supabase's built-in authentication and connection pooling rather than requiring separate database credential configuration
Exposes Supabase Auth session state and user metadata through MCP tools, allowing agents to inspect current authentication context, retrieve user profiles, and trigger auth-related operations. Integrates with Supabase's JWT-based auth system to validate sessions and access user claims without re-authenticating, using the Supabase client's built-in session management.
Unique: Integrates Supabase's JWT-based auth system directly into MCP tool interface, allowing agents to inspect and act on auth state without managing separate credential stores or re-authentication flows
vs alternatives: More seamless than generic auth MCP servers because it leverages Supabase's built-in session management and avoids redundant credential passing between agent and auth system
Invokes Supabase Edge Functions (serverless TypeScript/JavaScript functions) through MCP tools, passing parameters and receiving results with optional streaming support. Uses Supabase's edge function HTTP API to trigger functions with automatic authentication headers and response parsing, enabling agents to execute custom business logic without embedding it in the agent itself.
awesome-llm-apps scores higher at 47/100 vs Supabase at 42/100.
Need something different?
Search the match graph →© 2026 Unfragile. Stronger through disorder.
Unique: Exposes Supabase Edge Functions as MCP tools with automatic authentication and response parsing, allowing agents to invoke custom serverless logic without managing HTTP clients or credential injection
vs alternatives: More integrated than generic HTTP MCP tools because it handles Supabase-specific authentication, error handling, and response formatting automatically
Subscribes to real-time changes on Supabase tables through MCP's event streaming interface, using Supabase's PostgreSQL LISTEN/NOTIFY mechanism to push INSERT, UPDATE, and DELETE events to agents. Maintains persistent WebSocket connections and filters events by table and row-level policies, enabling agents to react to database changes without polling.
Unique: Bridges Supabase's PostgreSQL LISTEN/NOTIFY real-time system with MCP's tool interface, enabling agents to subscribe to database changes without managing WebSocket connections or event serialization
vs alternatives: More efficient than polling-based approaches because it uses Supabase's native real-time infrastructure rather than repeated database queries
Manages files in Supabase Storage buckets through MCP tools, supporting upload, download, list, and delete operations with automatic authentication and path-based access control. Uses Supabase's S3-compatible storage API with built-in support for public/private buckets and signed URLs for temporary access, enabling agents to handle file I/O without managing cloud storage credentials.
Unique: Exposes Supabase Storage's S3-compatible API as MCP tools with automatic authentication and signed URL generation, eliminating the need for agents to manage cloud storage credentials or generate temporary access tokens
vs alternatives: More integrated than generic S3 MCP tools because it leverages Supabase's built-in bucket policies and authentication rather than requiring separate AWS credentials
Performs semantic similarity searches on vector embeddings stored in Supabase PostgreSQL using pgvector extension, translating natural language queries into embedding vectors and executing cosine/L2 distance searches. Integrates with embedding providers (OpenAI, Cohere) or uses pre-computed embeddings, enabling agents to retrieve semantically similar documents or records without full-text search limitations.
Unique: Integrates pgvector directly into MCP tools with automatic embedding generation and distance calculation, enabling agents to perform semantic search without managing separate vector database infrastructure
vs alternatives: More efficient than external vector databases (Pinecone, Weaviate) for Supabase users because it colocates embeddings with relational data, reducing network latency and simplifying data synchronization
Exposes Supabase database schema information through MCP tools, allowing agents to discover table structures, column types, constraints, and relationships without manual schema documentation. Queries PostgreSQL information_schema and Supabase metadata tables to dynamically generate schema descriptions, enabling agents to construct valid queries and understand data relationships.
Unique: Queries Supabase's PostgreSQL information_schema directly through MCP tools, enabling agents to dynamically discover and adapt to database schemas without pre-configured schema definitions
vs alternatives: More flexible than static schema definitions because it reflects live database state, including recent migrations or schema changes
Enforces Supabase Row-Level Security policies within agent queries, ensuring that agents can only access rows permitted by RLS rules defined in the database. Evaluates policies based on authenticated user context (JWT claims, user ID) and applies WHERE clause filters automatically, preventing unauthorized data access at the database layer rather than application layer.
Unique: Delegates authorization enforcement to PostgreSQL RLS policies rather than implementing authorization in agent code, ensuring that data access rules are centralized and cannot be bypassed by agent logic
vs alternatives: More secure than application-level authorization because RLS is enforced at the database layer, preventing accidental data leaks even if agent code has bugs
+1 more capabilities