Shubhamsaboo/awesome-llm-apps

This repository is a comprehensive collection of demo applications and tutorials focused on building and orchestrating AI agents. It provides concrete implementations of single-agent, multi-agent, and generative UI patterns across diverse domains such as finance, research, coding, and creative content generation. The system serves as a practical reference for integrating large language models with external tools, vector databases, and web services using various frameworks like Agno, Google ADK, and LangGraph.

99 changes.

This period focused on expanding the repository's coverage of Retrieval-Augmented Generation (RAG) and multi-agent architectures, introducing numerous tutorials for autonomous, hybrid, and agentic RAG systems. It also saw the addition of diverse single and multi-agent applications for specialized tasks like travel planning, research, and code generation, alongside significant updates to standardize dependencies and migrate agents to newer frameworks like Agno v2.0 and Google ADK.

44 changes.

This period focused on expanding the library with complex multi-agent pipelines for specialized domains such as investment due diligence, sales intelligence, and insurance claims, alongside new tutorials on agent governance and trust layers. It also introduced a significant set of generative UI applications using CopilotKit and AG-UI, including financial coaching and dashboard canvases, while adding practical developer tools like agent skills for code analysis and dependency management.

The AI Meme Generator Agent now supports selecting Google's Gemini model (defaulting to gemini-3-flash-preview) alongside the existing Claude, OpenAI, and Deepseek options, with a fixed temperature of 0.3 for these models. The project also introduces support for the uv package manager, allowing users to install dependencies and run the agent via uv sync and uv run commands in addition to the traditional pip workflow.

_starter\_ai\_agents/ai\_meme\_generator\_agent\browseruse · high confidence

A new Streamlit-based application has been added to automate the recruitment workflow using a team of specialized AI agents. The system includes a Resume Analyzer for technical skill evaluation, an Email Communication agent for professional correspondence, and an Interview Scheduler agent that integrates with Zoom API to coordinate meetings. Users can upload resumes, receive automated feedback, and manage the end-to-end hiring process through a unified interface powered by OpenAI GPT-4o and the Phidata framework.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_recruitment\_agent\team · high confidence

The AI Travel Agent application has been updated to allow users to download their generated itineraries as .ics calendar files, which can be imported into Google Calendar, Apple Calendar, or other calendar apps. Additionally, a new local version of the agent (local\_travel\_agent.py) has been introduced, enabling users to run the planner using the local Llama-3.2 model via Ollama, offering an alternative to the cloud-based GPT-4o version that requires an OpenAI API key. Both versions retain the core functionality of researching destinations and planning personalized itineraries based on user preferences.

_starter\_ai\_agents/ai\_travel\agent · high confidence

This location introduces the frontend interface for the AI Dashboard Canvas Agent, enabling users to build and manage analytics dashboards through a conversational CopilotKit chat. The \page.tsx\ and \layout.tsx\ files wire up the \CopilotKit\ runtime to a backend agent at \/api/copilotkit\, while the \chat\ components provide a responsive UI with suggestions and custom message rendering. The \dashboard\ components implement the core dashboard state management, allowing users to add, edit, and remove charts (line, bar, pie) and pinned metrics via the \ChartGrid\ and \PinnedMetrics\ components, with visual feedback provided by \ChartRenderer\ and \ChartCard\.

_generative\_ui\agents/ai-dashboard-canvas-agent · high confidence

The AQI Analysis Agent in this directory now provides two distinct user interfaces for interacting with the multi-agent system: a Gradio-based web app (ai\_aqi\_analysis\_agent\_gradio.py) and a Streamlit-based web app (ai\_aqi\_analysis\_agent\_streamlit.py). Both interfaces allow users to input location details (city, state, country), medical conditions, and planned activities to receive personalized health recommendations based on real-time air quality data fetched via Firecrawl. The Gradio interface displays results in a simple web block, while the Streamlit interface offers a more structured layout with sidebar API key configuration and expandable raw data views. A README.md has also been added to guide users through setup and usage.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_aqi\_analysis\agent · high confidence

This location introduces a new Streamlit-based example application that demonstrates a multi-agent research workflow built on AG2. The app allows users to upload local documents (PDF, TXT, MD) and ask research questions, featuring a triage agent that routes queries to either local document search or a web search fallback via SearxNG. The pipeline includes distinct agents for local/web research, evidence verification, and final synthesis with citations, providing a concrete implementation of agent teamwork and adaptive routing.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ag2\_adaptive\_research\team · high confidence

Introduces a new multi-agent application that coordinates a Web Agent and a Finance Agent to provide comprehensive financial insights. The system uses GPT-4o, YFinance for real-time stock data and analyst recommendations, and DuckDuckGo for web research, with interactions persisted in SQLite and accessible via a web playground interface.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_finance\_agent\team · high confidence

Introduces a new Streamlit-based tutorial application that integrates with the Contextual AI managed RAG platform. Users can now create datastores, ingest documents (PDFs, HTML, etc.), and configure agents to generate retrieval-grounded responses using Contextual’s Grounded Language Model. The app supports advanced features such as document reranking, retrieval visualization with attribution page images, and answer evaluation via LMUnit.

_rag\_tutorials/contextualai\_rag\agent · high confidence

The generative\_ui\_agents/mcp-apps-generative-ui-showcase location now includes a complete Next.js application that demonstrates CopilotKit v2 with MCP Apps middleware. The entry point (src/app/page.tsx) provides a landing page with four interactive demo apps: Airline Booking, Hotel Booking, Investment Simulator, and Kanban Board. The backend API route (src/app/api/copilotkit/\[\[...slug\]\]/route.ts) configures a CopilotKit runtime with an agent that uses MCP Apps middleware to connect to an external MCP server (defaulting to http://localhost:3001/mcp). The application includes a custom media query hook (src/hooks/use-media-query.ts) for responsive design and a global stylesheet (src/app/globals.css) implementing a CopilotKit-inspired design system with animated abstract backgrounds. The layout (src/app/layout.tsx) sets up the root layout with CopilotKit v2 styles and metadata.

_generative\_ui\agents/mcp-apps-generative-ui-showcase · high confidence

This change introduces two new tutorial examples for the Google Agent Development Kit (ADK). The first, a 'Starter Agent', provides a creative writing assistant using the \gemini-3-flash-preview\ model to demonstrate basic agent creation and configuration. The second, a 'Structured Output Agent' section, includes two examples: a customer support ticket creator and an email generator. These examples utilize Pydantic schemas to enforce type-safe, structured JSON responses from the \gemini-3-flash-preview\ model, illustrating how to handle complex data structures and validation within ADK agents.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/1\_starter\_agent, ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/3\_structured\_output\agent · high confidence

Introduces a new Streamlit application that generates MP3 music tracks using the ModelsLab API and OpenAI's GPT-4 model. Users provide OpenAI and ModelsLab API keys via the sidebar to authenticate, then enter a descriptive prompt to generate music. The app handles the agent execution, downloads the resulting audio file, validates the content type, and provides in-browser playback and download options.

_starter\_ai\_agents/ai\_music\_generator\agent · high confidence

Introduced a new multi-agent research application in the starter\_ai\_agents directory, built with OpenAI's Agents SDK and Streamlit. The app features a Triage Agent for planning, a Research Agent for web searches, and an Editor Agent for compiling reports, providing an interactive UI for users to conduct comprehensive research and view generated reports with source citations.

_starter\_ai\_agents/openai\_research\agent · high confidence

Added a new tutorial in the \mcp\_ai\_agents/openai\_remote\_mcp\_bridge\ directory that demonstrates how to connect a plain OpenAI function-calling loop to a hosted Streamable HTTP MCP server without using an agent framework. The included \openai\_remote\_mcp\_bridge.py\ script and \README.md\ provide a complete, runnable example that discovers remote MCP tools, converts their schemas to OpenAI function definitions, and dispatches model requests through a live MCP session with bounded tool-call budgets and result truncation.

_mcp\_ai\_agents/openai\_remote\_mcp\bridge · high confidence

Introduces a new tutorial demonstrating a multi-agent orchestration pattern using the Google ADK. The implementation features a coordinator agent that manages a sequential workflow of three specialized sub-agents: a Research Agent (using Google Search), a Summarizer Agent, and a Critic Agent. All agents are configured to use the 'gemini-3-flash-preview' model, and the tutorial includes setup instructions for running the system via ADK Web.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/8\_simple\_multi\agent · high confidence

Introduces a new multi-agent web research system implemented via YAML configuration files within the Google ADK framework. The system features a coordinator agent that orchestrates a specialized research agent and a summary agent. The research agent utilizes Firecrawl MCP tools for web scraping and content analysis, while the summary agent generates structured reports. The configuration defaults to the \gemini-3-flash-preview\ model and includes setup instructions for both Google AI Studio and Vertex AI environments.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/adk\_yaml\examples · high confidence

New Streamlit application files have been added to the chat\_with\_research\_papers tutorial, enabling users to interact with arXiv research papers. The primary entry point, chat\_arxiv.py, uses OpenAI's GPT-4o model via the agno library to provide conversational access to scholarly articles. Additionally, chat\_arxiv\_llama3.py provides a local alternative using the Llama 3.1 model via Ollama, allowing users to run the same arXiv search and chat functionality without cloud API dependencies.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\_research\papers · high confidence

Introduced a new Customer Support Voice Agent that allows users to crawl documentation websites, build a searchable vector knowledge base using Qdrant and FastEmbed, and answer queries via text or natural-sounding voice responses using OpenAI's GPT-4o and TTS capabilities. The agent features a Streamlit interface for configuring API keys, selecting from multiple voice options, and processing documentation, with progress indicators and audio playback support.

_voice\_ai\_agents/customer\_support\_voice\agent · high confidence

A new demo application is available at \rag\_tutorials/multimodal\_agentic\_rag\ that ingests text, URLs, PDFs, images, audio, and video into a local in-memory index using Gemini Embedding 2. The app features a React + Vite frontend with a 3D PCA embedding view and a FastAPI backend that uses a Google ADK agent to coordinate retrieval and answer generation. Users can add and remove sources, ask questions, and view grounded answers with separate citation panels, all powered by cosine similarity search over the multimodal embeddings.

_rag\_tutorials/multimodal\_agentic\rag · high confidence

The \ai\_self\_evolving\_agent\ directory now includes a runnable example that demonstrates an automated workflow: it takes a natural-language goal (such as generating a Tetris game), uses EvoAgentX to generate and execute a multi-agent workflow with OpenAI's gpt-4o-mini, and then employs a separate Anthropic Claude model via LiteLLM to verify and repair the generated code. Users can run this example by installing the specified dependencies, setting their OpenAI and Anthropic API keys, and executing the provided Python script, which outputs the final HTML file to a local directory.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_self\_evolving\agent · high confidence

This location introduces three new interactive tutorials for the Google ADK multi-agent patterns, each with its own Streamlit web interface and agent logic. The Sequential Agent tutorial (9\_1) demonstrates a Business Implementation Plan Generator that orchestrates four sub-agents in a pipeline, using a Search Agent wrapped as an AgentTool for real-time market research. The Loop Agent tutorial (9\_2) provides an Iterative Plan Refiner that uses a LoopAgent to repeatedly refine a plan until a target iteration count is reached or an acceptance flag is set, persisting state across iterations. The Parallel Agent tutorial (9\_3) showcases a Market Snapshot Team that runs three research agents concurrently to gather market trends, competitor intelligence, and funding news in parallel, writing results to distinct keys in shared session state. All agents use the gemini-3-flash-preview model.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/9\_multi\_agent\patterns · high confidence

New tutorial examples have been added to the Google ADK crash course to demonstrate session management. Tutorial 5.1 introduces an in-memory conversation agent using \InMemorySessionService\ for temporary, single-session context, while Tutorial 5.2 demonstrates persistent memory using \DatabaseSessionService\ with SQLite to retain conversation history across program restarts. Both tutorials include Python agent implementations, Streamlit web interfaces, and configuration files.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/5\_memory\agent · high confidence

Added tutorial examples for the Google ADK crash course that demonstrate how to create agents using different AI models (OpenAI GPT-4o and Anthropic Claude 4 Sonnet) through a unified OpenRouter API. The update includes two new agent implementations (\2\_1\_openai\_adk\_agent\ and \2\_2\_anthropic\_adk\_agent\) that use the \LiteLlm\ adapter to access these models via a single \OPENROUTER\_API\_KEY\, along with a README explaining how to compare responses from different providers side-by-side.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/2\_model\_agnostic\agent · high confidence

This change introduces the initial version of the Multimodal Video Moment Finder application's Next.js frontend. It provides a user interface for uploading videos, which are processed to extract frames and build a visual index, and for searching those videos using either text queries or image uploads. The interface displays search results with relevance scores, allows users to jump to specific moments in the video player, and includes visual styling for glass panels, animations, and responsive feedback.

_advanced\_llm\_apps/multimodal\_video\_moment\finder/frontend · high confidence

Adds a new automated B2B outreach agent that discovers target companies, identifies decision-makers, and generates personalized cold emails. The implementation is updated to use the Agno v2 framework (specifically the Team API) and includes a comprehensive README with step-by-step tutorial links and configuration instructions for Exa and OpenAI API keys.

_advanced\_ai\_agents/single\_agent\_apps/ai\_email\_gtm\_reachout\agent · high confidence

Adds a new AI Financial Coach demo application under \generative\_ui\_agents/ai-financial-coach-agent\. This Next.js app provides a user interface for interacting with a multi-agent financial planning system, featuring a chat sidebar powered by CopilotKit and interactive cards for budget analysis, savings strategies, and debt reduction plans. The application includes a financial data entry form, connects to a backend agent via an API route, and renders detailed financial insights such as spending category breakdowns, emergency fund progress, and debt payoff strategies (avalanche vs. snowball).

(repo-wide) · high confidence

Adds a new Streamlit-based demo agent that investigates subsidized childcare providers in Cook County, Illinois, by cross-referencing DCFS licensing records with Cook County GIS property data, Google Street View imagery, and Secretary of State business registrations. The agent narrates its reasoning in real time, flagging anomalies such as licensed capacities that exceed building code limits or addresses that do not match the claimed business type, while explicitly limiting its scope to public data and avoiding definitive fraud accusations.

_advanced\_ai\_agents/single\_agent\_apps/ai\_fraud\_investigation\agent · high confidence

Users can now access the AI Home Renovation Planner, a multi-agent application built on Google ADK that analyzes room photos and inspiration images to create personalized renovation plans and photorealistic renderings. The system leverages Gemini 3 Flash and Gemini 3 Pro for multimodal capabilities, featuring a Coordinator/Dispatcher pattern with specialized agents for visual assessment, design planning, and project coordination. Key capabilities include budget-aware planning, timeline estimation, and iterative refinement of renderings, with automatic version tracking for all generated artifacts to preserve layout and history.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_home\_renovation\agent · high confidence

Users can now upload source code and documentation files to automatically generate an interactive knowledge graph. The application features a CopilotKit-powered chat interface that processes the uploaded content to extract entities, concepts, and relationships, visualizing them in a force-directed graph. Users can click nodes to view details and connections, and use suggested prompts to find deeper insights or trace dependencies. The UI includes dark mode support, collapsible JSON data blobs, and a tool-reasoning indicator to show the agent's progress.

_generative\_ui\agents/ai-knowledge-explorer · high confidence

Adds a new Streamlit-based agent application that leverages the Agno framework and OpenAI GPT-5 mini to provide recipe discovery, nutrition analysis, cost estimation, and weekly meal planning. The agent integrates with the Spoonacular API for detailed recipe and nutritional data, supports dietary restrictions, and includes a built-in cost estimation tool with budget tips. Users can interact via a web interface to find recipes based on ingredients, analyze nutritional content, and generate balanced meal plans with shopping lists.

_advanced\_ai\_agents/single\_agent\_apps/ai\_recipe\_meal\_planning\agent · high confidence

Adds a new Streamlit-based application that implements a multi-phase AI research agent. The app uses Google's Interactions API to orchestrate stateful conversations across three phases: planning with Gemini 3 Flash, deep research via the Deep Research Agent, and synthesis with Gemini 3 Pro, including automatic generation of TL;DR infographics. It demonstrates background execution, model mixing, and context retention via interaction IDs.

_advanced\_ai\_agents/single\_agent\_apps/research\_agent\_gemini\_interaction\api · high confidence

The application now features a sophisticated multi-agent system built on the Agno framework, utilizing GPT-4o to generate detailed, day-by-day travel itineraries. It integrates real-time data from Airbnb for accommodation pricing and availability, alongside a custom Google Maps MCP server for precise distance calculations and location services. Users can input destination, budget, and preferences to receive comprehensive plans including dining, activities, and transportation, with the added ability to export the itinerary as an ICS calendar file for import into Google Calendar, Apple Calendar, or Outlook.

_mcp\_ai\_agents/ai\_travel\_planner\_mcp\_agent\team · high confidence

Adds the Beifong project, a new multi-agent application for generating podcasts from web sources. This location provides the core agent logic and infrastructure, including agents for searching diverse sources (via DuckDuckGo, Google News, Wikipedia, etc.), scraping and verifying content quality, generating structured podcast scripts with distinct speaker personas, creating DALL-E cover images, and producing audio using OpenAI's TTS. It also includes the database schema for managing sessions and articles, a Celery worker for background tasks, and a bootstrap script to download demo content.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_news\_and\_podcast\agents · high confidence

A new local development tool, the Dependency Doctor skill, is available to inspect dependency manifests (requirements.txt, pyproject.toml, and package.json) for surface-level issues. It detects standard-library shadowing, obsolete backports, unpinned dependencies, duplicates, and conflicting pins without modifying files. An optional online mode can check for fully yanked PyPI releases, but network access requires explicit user approval.

_agent\skills/dependency-doctor · high confidence

Adds a new reference application in \advanced\_ai\_agents/multi\_agent\_apps/devpulse\_ai\ that demonstrates a multi-agent pipeline for aggregating technical signals from GitHub, ArXiv, HackerNews, Medium, and HuggingFace. The implementation uses the \agno\ framework with a specific design philosophy: deterministic data collection and normalization are handled by a non-agent utility (\SignalCollector\), while reasoning tasks are delegated to specialized agents (\RelevanceAgent\, \RiskAgent\, \SynthesisAgent\) using OpenAI models (defaulting to \gpt-4.1-mini\ for classification and \gpt-4.1\ for synthesis). The package includes a Streamlit dashboard for interactive exploration, a mock-data verification script for offline testing, and a \.gitignore\ to clean up build artifacts.

_advanced\_ai\_agents/multi\_agent\_apps/devpulse\ai · high confidence

Adds a new interactive CLI assistant that orchestrates multiple Model Context Protocol (MCP) servers for GitHub, Perplexity, Calendar, and Gmail integrations. The agent, built on the Agno framework and powered by OpenAI GPT-4o, features session-specific user and session IDs, conversation memory persistence via SQLite, and tool chaining capabilities for cross-platform workflows.

_mcp\_ai\_agents/multi\_mcp\agent · high confidence

Adds a new application that allows users to find specific moments in a video using either an image or a text description. The solution features a Next.js frontend and a Python FastAPI backend, utilizing Gemini Embedding 2 for native cross-modal search without transcription. Users can upload videos to extract frames, which are then embedded and stored in ChromaDB, enabling visual or textual queries to locate and jump to the corresponding video timestamps.

_advanced\_llm\_apps/multimodal\_video\_moment\finder · high confidence

Adds a new RAG tutorial application named PharmaQuery, featuring a Streamlit interface for querying pharmaceutical insights. Users can input Google Gemini API keys, upload PDF research documents to populate a ChromaDB vector store, and submit natural language questions to receive answers based on the retrieved context.

_rag\_tutorials/rag\chain · high confidence

A new local agent skill, Project Graveyard, scans your machine for abandoned git repositories and analyzes their history to determine why they died (e.g., deploy fear, payments wall, shiny object syndrome). It identifies personal development patterns, ranks projects by 'pulse' (resurrection potential), and provides a step-by-step plan to ship the most promising one. The tool runs entirely offline using Python 3.8+ and stdlib, ensuring privacy by only reading git metadata and never accessing code contents.

_agent\skills/project-graveyard · high confidence

Adds the ThinkPath Chatbot application, an Electron-based desktop tool that integrates with local Ollama instances to provide guided, step-by-step strategic thinking paths. Users can select from multiple generated approaches and execute them incrementally, allowing for controlled depth of analysis and reduced token usage compared to standard chat interfaces. The app includes a custom UI for managing these paths and handles local model communication via IPC.

_advanced\_llm\_apps/thinkpath\_chatbot\app · high confidence

A new Streamlit-based application is added that implements a multi-agent research pipeline (Researcher → Analyst → Writer) where agents must pass a trust verification score before participating. The system includes a local trust registry that tiers agents (gold/silver/bronze) and blocks those below a configurable threshold. Every action within the pipeline is recorded in a tamper-evident, hash-chained audit trail using SHA-256, allowing users to independently verify the integrity of the agent interactions via a visual dashboard.

_advanced\_ai\_agents/multi\_agent\_apps/trust\_gated\_agent\team · high confidence

This change adds the 'Windows-Use' single-agent application, which enables an LLM to directly control the Windows desktop GUI. The agent uses the \windows\_use\ Python library to perform actions such as clicking, typing, launching apps, and executing shell commands by interacting with UI elements. It is configured to use Google's Gemini model (via \langchain\_google\_genai\) and requires a \GOOGLE\_API\_KEY\ environment variable. The package includes a \main.py\ entry point, a \uv.lock\ dependency manifest, and supporting code for agent state, tool registry, and prompt templating.

_advanced\_ai\_agents/single\_agent\_apps/windows\_use\_autonomous\agent · high confidence

This change adds a new directory structure for agent skills, including evaluation tools and a frontend application. The \agent\_skills/evals/tools\ directory introduces three Python scripts: \run\_trigger\_evals.py\ for lexical trigger and routing validation, \skill\_lint.py\ for validating skill directories against the agentskills.io specification, and \skill\_scanner.py\ for static security scanning of skills against OWASP Agentic Skills Top 10 patterns. Additionally, the \agent\_skills/self-improving-agent-skills/frontend\ directory adds a Next.js application that provides a user interface for uploading skills, configuring test scenarios and evaluation criteria, running optimization experiments, and viewing results with diff views and download capabilities.

_agent\_skills/evals/tools, agent\skills/self-improving-agent-skills/frontend · high confidence

The \insurance\_claim\_live\_agent\_team\ module now provides a voice-first insurance claim intake experience powered by Gemini 3.8 Live. Users can start a live call where the agent listens, transcribes, and writes a self-updating field notebook with extracted facts. The agent can also view the claimant's camera feed to identify damage, pinning photo frames into the notebook with observations, and generate incident sketches for verification. Behind the scenes, a background agent team verifies policy status against a mock directory, runs an ADK graph for classification and routing, and applies deterministic business rules for evidence, safety, and fraud signals, all while keeping the conversation flowing without blocking.

_voice\_ai\_agents/insurance\_claim\_live\_agent\team · high confidence

Adds a new tutorial demonstrating how to build a trust layer for multi-agent systems, enabling secure agent-to-agent communication through verifiable identities, behavioral trust scoring (0-1000), and cryptographically scoped delegation chains. The included Python implementation and documentation show how to enforce policies, restrict agent actions to specific domains and actions, and maintain a full audit trail of interactions.

_advanced\_ai\_agents/multi\_agent\_apps/multi\_agent\_trust\layer · high confidence

This change adds a new self-improving agent skills capability, allowing users to upload agent skills and automatically optimize them using a multi-agent system built with Google ADK and Gemini. The backend (FastAPI) implements an optimization loop where three specialized agents collaborate: an Executor runs the skill against test scenarios and scores outputs, an Analyst diagnoses failures and selects mutation strategies, and a Mutator applies targeted fixes to the skill prompt. The frontend (Next.js 15, React 19, Tailwind CSS v4) provides a UI for uploading skills, configuring test scenarios and evaluation criteria, and monitoring the optimization progress via Server-Sent Events (SSE). Users can download the improved skill along with a detailed changelog.

_agent\skills/self-improving-agent-skills · high confidence

The AI Negotiation Battle Simulator now features a new web-based frontend built with Next.js and CopilotKit. This update adds a 'Warm Editorial' visual design with specific typography and color palettes, and integrates an AG-UI agent interface that allows users to interact with the negotiation simulation through a chat-style UI. The frontend includes components for displaying negotiation rounds, offers, and deal outcomes, connecting to the backend agent via a dedicated API route.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_negotiation\_battle\simulator/frontend · high confidence

Users can now upload video presentations to receive comprehensive, AI-driven feedback on their public speaking skills. This new application leverages a multi-agent architecture (via Agno) to analyze facial expressions, vocal attributes (pace, pitch, volume), and content structure (grammar, filler words). The system provides a detailed evaluation report including scores across five criteria, personalized strengths and weaknesses, and actionable suggestions for improvement, all accessible through a Streamlit frontend and FastAPI backend.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_speech\_trainer\agent · high confidence

A new multi-agent application has been added that simulates real-time negotiations between two AI agents (a buyer and a seller) with distinct personalities and strategies. The backend, built with Google ADK and FastAPI, manages the negotiation logic, scenarios, and agent orchestration, exposing an AG-UI endpoint for real-time streaming. The frontend, a Next.js application using CopilotKit and AG-UI, provides a reactive 'Battle Arena' UI that visualizes the negotiation timeline, agent states, and tool calls as they happen. Users can configure scenarios (e.g., used car sales, vintage guitar deals) and select from eight unique agent personalities to watch the AI agents negotiate.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_negotiation\_battle\simulator · high confidence

Added a new tutorial demonstrating a local RAG application that uses hybrid search (combining semantic and keyword matching) with local LLMs and embeddings. The entry includes a Streamlit-based chat interface (local\_main.py) for uploading PDFs, configuring local model paths (e.g., Llama-3.2-3B, BGE-M3), and setting up a PostgreSQL database, along with comprehensive documentation (README.md) and a demo video.

_rag\_tutorials/local\_hybrid\_search\rag · high confidence

This location introduces a new Streamlit application that implements a multi-agent career coaching assistant using Google's Agent Development Kit (ADK). The app features a root 'career orchestrator' that automatically delegates user questions to one of four specialist sub-agents: resume review, interview practice, skills/learning roadmap, or salary benchmarking. It integrates Mem0 with an embedded Qdrant vector store to maintain persistent, long-term memory of each candidate's career history (such as target roles, tech stack, and past interview weaknesses) across sessions, ensuring advice becomes increasingly specific over time. The application is configured to use the Gemini-3.7-flash model for both the agent's reasoning and Mem0's internal fact extraction, requiring only a single Google API key to run without external services like Docker or OpenAI.

_advanced\_llm\_apps/llm\_apps\_with\_memory\tutorials · high confidence

Added a new tutorial demonstrating how to build a governance layer for AI agents using deterministic policies. The included Python script and documentation show how to implement action interception, filesystem and network guards, rate limiting, and audit logging to prevent dangerous agent actions before execution.

_advanced\_ai\_agents/single\_agent\_apps/ai\_agent\governance · high confidence

Added a new tutorial demonstrating an agentic RAG application that uses LangGraph, Google Gemini, and Qdrant to search and answer questions about AI blog posts. The entry includes the Streamlit-based application code and documentation, featuring a workflow where an agent decides whether to retrieve documents, rewrite queries, or generate answers based on relevance grading.

_rag\_tutorials/ai\_blog\search · high confidence

A new multi-agent application has been added to plan and execute codebase migrations. It uses LangGraph to orchestrate a Planner that generates a file-by-file migration strategy, followed by a Human-in-the-Loop approval gate where users can review and modify risk levels before execution. The system then fans out parallel refactoring workers to generate diffs and test cases for each file, which are aggregated into a final report with visual risk charts. The app includes a Streamlit UI for configuration and interaction, and enforces security by validating inputs and preventing dynamic code execution in chart generation.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_codebase\_migration\agent · high confidence

A new AI Consultant Agent has been added to the single-agent applications, built on Google's Agent Development Kit (ADK) using the Gemini 2.5 Flash model. This agent provides business consultation services including real-time market research via Perplexity AI's 'sonar' model, strategic planning, and risk assessment. It features an interactive web interface accessible at localhost:8000, session tracking for evaluation, and requires both Google and Perplexity API keys to function.

_advanced\_ai\_agents/single\_agent\_apps/ai\_consultant\agent · high confidence

A new Streamlit-based demo application has been added that implements an AI customer support agent capable of remembering past interactions. The agent uses OpenAI's GPT-4 model and integrates the Mem0 library with a Qdrant vector store to maintain persistent memory of customer profiles and conversation history. Users can generate synthetic customer data, view customer profiles and memory logs, and chat with the agent, which retrieves relevant past information to provide context-aware responses.

_advanced\_ai\_agents/single\_agent\_apps/ai\_customer\_support\agent · high confidence

Introduces a new Streamlit-based agent that allows users to upload CSV datasets and ask natural language questions to receive interactive visualizations and statistical insights. The application integrates with Together AI for LLM inference and E2B for secure code execution, supporting multiple models including Meta-Llama 3.1 405B, DeepSeek V3, Qwen 2.5 7B, and Meta-Llama 3.3 70B. It automatically selects appropriate chart types and displays generated plots, dataframes, or text responses directly in the UI.

_starter\_ai\_agents/ai\_data\_visualisation\agent · high confidence

A new AI agent application has been added to the multi-agent apps collection, enabling users to conduct comprehensive domain-specific research. Built on the Agno framework and powered by Together AI's Qwen model, the agent automatically generates targeted research questions, performs multi-source analysis using Tavily and Perplexity AI via Composio tools, and compiles findings into a professional, McKinsey-style report. The application features a Streamlit-based user interface for managing API keys and viewing results, with optional integration to create the final report directly in Google Docs. A dedicated README provides step-by-step guidance for setup and usage.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_domain\_deep\_research\agent · high confidence

Added a new multi-agent Streamlit application that automates B2B outreach by discovering relevant companies, identifying key decision-makers, gathering research insights from websites and Reddit, and drafting personalized emails. The app utilizes the agno framework (importing RunOutput and SqliteDb) and OpenAI models (specifically gpt-5 and gpt-4o) to execute a four-stage workflow: Company Finder, Contact Finder, Researcher, and Email Writer. Users can configure the number of target companies and select from four email styles (Professional, Casual, Cold, Consultative) via the UI, with API keys for OpenAI and Exa managed securely through environment variables.

(repo-wide) · high confidence

A new Streamlit-based application has been added to generate personalized dietary and fitness plans. The app uses the Agno framework with two specialized agents (Dietary Expert and Fitness Expert) powered by the Gemini model (gemini-2.5-flash-preview-05-20) to create tailored meal plans and exercise routines based on user profile inputs such as age, weight, activity level, and fitness goals. The entry also includes a README with setup instructions and a link to a step-by-step tutorial.

_advanced\_ai\_agents/single\_agent\_apps/ai\_health\_fitness\agent · high confidence

A new Streamlit-based AI Journalist Agent has been added to the single-agent applications. This demo allows users to generate high-quality articles on any topic by orchestrating a Searcher agent (using SerpAPI for web research), a Writer agent (using Newspaper4k for content retrieval), and an Editor team (using OpenAI GPT-4o) to refine the final output.

_advanced\_ai\_agents/single\_agent\_apps/ai\_journalist\agent · high confidence

A new Medical Imaging Diagnosis Agent has been added to the starter agents collection. Built on the agno framework and powered by the Gemini 2.5 Pro model, this Streamlit application allows users to upload medical images (JPG, JPEG, PNG, DICOM) for AI-assisted analysis. The agent identifies image types and anatomical regions, lists key findings and potential abnormalities, provides diagnostic assessments with differential diagnoses, and offers patient-friendly explanations. It also leverages DuckDuckGo to search for relevant medical literature and treatment protocols to support its analysis.

_starter\_ai\_agents/ai\_medical\_imaging\agent · high confidence

A new Streamlit-based AI Movie Production Agent has been added, enabling users to generate script outlines and casting suggestions for movie concepts. The application utilizes a team of agents powered by the Gemini 2.5 Flash model, where a ScriptWriter creates the narrative structure and a CastingDirector uses SerpAPI tools to suggest actors based on current availability. Users must provide their own Google API key for the LLM and a SerpAPI key for search functionality to run the agent.

_advanced\_ai\_agents/single\_agent\_apps/ai\_movie\_production\agent · high confidence

This location introduces a new multi-agent application that allows users to search and analyze real estate listings across Zillow, Realtor.com, Trulia, and Homes.com. The demo provides two execution modes: a cloud version using Google Gemini 2.5 Flash and a local version using Ollama (gpt-oss:20b), both leveraging Firecrawl for data extraction. The system employs a sequential agent workflow comprising a Property Search Agent, a Market Analysis Agent, and a Property Valuation Agent to provide comprehensive insights, including price trends, neighborhood analysis, and investment potential assessments.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_real\_estate\_agent\team · high confidence

Added a new AI Reasoning Agent starter that demonstrates advanced reasoning capabilities using the agno library. Users can run a local version powered by the Ollama model (qwq:32b) via an interactive web playground, or compare a standard GPT-4o-mini agent against a GPT-4o agent with explicit reasoning and structured output features enabled in a command-line interface.

_starter\_ai\_agents/ai\_reasoning\agent · high confidence

This change introduces a new multi-agent workflow, the AI SEO Audit Team, built on Google ADK. It automates the process of auditing a webpage by sequentially running a Page Auditor (which scrapes the URL using Firecrawl via MCP), a SERP Analyst (which researches competitors via Google Search), and an Optimization Advisor (which generates a prioritized Markdown report with actionable SEO recommendations). The feature includes the agent definitions, required Python dependencies, and a README with setup instructions and a link to a step-by-step tutorial.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_seo\_audit\team · high confidence

A new multi-agent pipeline has been added to generate competitive sales battle cards. Built on Google ADK and Gemini 3, the system performs live competitor research, feature analysis, SWOT assessment, and objection handling to produce professional HTML battle cards and visual comparison infographics for sales teams.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_sales\_intelligence\_agent\team · high confidence

Added a new Streamlit-based demo application that provides expert software architecture analysis using a dual-model approach: DeepSeek R1 performs initial technical reasoning and structured analysis, while Claude 3.5 generates detailed explanations, implementation roadmaps, and technical specifications. The application requires both DeepSeek and Anthropic API keys and supports analysis types including real-time event processing, healthcare data platforms, financial trading systems, multi-tenant SaaS solutions, CDNs, and supply chain management systems.

_advanced\_ai\_agents/single\_agent\_apps/ai\_system\_architect\r1 · high confidence

A new multi-agent pipeline has been added to the advanced AI agents library to automate startup investment due diligence. Built on Google ADK and Gemini models, this agent team performs a seven-stage sequential analysis: company research, market analysis, financial modeling (including Bear/Base/Bull revenue projections), risk assessment, investor memo generation, professional HTML report creation, and visual infographic summary. Users can analyze any startup by providing a company name or URL, and the system outputs structured investment memos, revenue charts, and McKinsey-style reports.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_vc\_due\_diligence\_agent\team · high confidence

Added two new Streamlit-based demo applications: an AI Deep Research Agent that uses the OpenAI Agents SDK and Firecrawl to perform comprehensive web research and generate enhanced reports, and an AI Meeting Preparation Agent that utilizes CrewAI with multiple agents (context analyzer, industry expert, strategist, and communication specialist) to create detailed meeting strategies and executive briefings. Both applications include step-by-step tutorial links in their README files to guide users through building and running the agents from scratch.

_advanced\_ai\_agents/single\_agent\_apps/ai\_deep\_research\_agent, advanced\_ai\_agents/single\_agent\_apps/ai\_meeting\agent · high confidence

Added several new Streamlit-based AI applications to the cursor\_ai\_experiments directory, including an AI web scraper using ScrapegraphAI, a local ChatGPT clone using Ollama's Llama 3.1, a RouteLLM chat app for intelligent model routing, a multi-agent AI researcher using CrewAI, and a local ChatGPT clone using LM Studio and Llama-3.

_advanced\_llm\_apps/cursor\_ai\experiments · high confidence

Added an interactive Streamlit application where two AI agents compete in Tic-Tac-Toe, featuring a referee agent to coordinate turns and validate moves. The game supports multiple language models (GPT-4o, o3-mini, Claude 3.5/3.7, Gemini, Llama 3) via the Agno framework, allowing users to select different models for each player through the UI. The interface includes real-time board visualization, move history tracking, and game state management.

_advanced\_ai\_agents/autonomous\_game\_playing\_agent\_apps/ai\_tic\_tac\_toe\agent · high confidence

Added a new starter agent that autonomously pays for data using the x402 standard. The agent uses Claude to select paid endpoints, automatically handles HTTP 402 challenges by signing USDC payments from a configured wallet, and enforces a per-call spending cap. The demo includes a local FastAPI seller (\seller.py\) to simulate paid APIs, allowing users to run the full payment loop on Base Sepolia testnet without real money.

_starter\_ai\_agents/ai\_x402\_paying\agent · high confidence

This update introduces two new agent-based applications to the repository. The AI Chess Agent allows two GPT-4o-mini agents to play a game of chess against each other within a Streamlit interface, featuring move validation and game state management. The AI Audio Tour Agent generates personalized, self-guided audio tours based on a user's location and interests (History, Architecture, Culinary, Culture), using a multi-agent architecture to research content and OpenAI's TTS to produce the final audio file. Both entries include updated READMEs with links to step-by-step tutorials.

_advanced\_ai\_agents/autonomous\_game\_playing\_agent\_apps/ai\_chess\_agent, voice\_ai\_agents/ai\_audio\_tour\agent · high confidence

Introduces 'The Magician IA Reader', a Streamlit-based application that provides AI-driven tarot card interpretations. Users can input natural language questions and select a 3, 5, or 7-card spread; the app uses the local 'phi4' model via Ollama to analyze the drawn cards against a CSV knowledge base of meanings and symbolism, returning detailed, context-aware readings with psychological advice.

_advanced\_llm\apps/chat-with-tarots · high confidence

This location introduces a new Agentic RAG tutorial that simulates a math professor solving JEE-level questions. The system uses a Qdrant vector database for knowledge retrieval and falls back to the Tavily web search API when no high-similarity match is found. It incorporates DSPy-based input and output guardrails to ensure questions are math-related and answers are safe/correct. A Streamlit UI allows users to ask questions, view step-by-step explanations, and provide human feedback (thumbs up/down) which is logged to a local JSON file. The tutorial also includes a benchmarking tool to evaluate accuracy on the JEEBench dataset.

_rag\_tutorials/agentic\_rag\_math\agent · high confidence

A new Streamlit-based application has been added to the rag\_tutorials/agentic\_rag\_gpt5 directory, demonstrating an agentic Retrieval-Augmented Generation (RAG) system. The app uses the Agno framework to orchestrate an agent that retrieves information from URLs via a LanceDB vector store and generates responses using the GPT-5 model. Users can configure their OpenAI API key, dynamically add knowledge sources by entering URLs, and interact with the agent through a streaming interface that supports markdown formatting. The entry includes the main application logic in agentic\_rag\_gpt5.py and a comprehensive README with setup instructions and a link to a step-by-step tutorial.

_rag\_tutorials/agentic\_rag\gpt5 · high confidence

This location introduces a new tutorial application (\agentic\_rag\_gemini.py\) that implements an Agentic RAG system using the Gemini 2.0 Flash Thinking model and the Agno framework. The application provides a Streamlit interface for document processing (PDFs and web pages), intelligent query rewriting, and vector storage in Qdrant. It features a toggle for web search fallback via Exa AI, allowing users to retrieve information from the web when local documents are insufficient, along with configurable similarity thresholds and domain filtering.

_rag\_tutorials/gemini\_agentic\rag · high confidence

Added a new tutorial application in the \rag\_tutorials/agentic\_rag\_with\_reasoning\ directory that demonstrates an AI agent performing step-by-step reasoning. The app uses Agno v2.0, Google Gemini 2.5 Flash for language processing, and OpenAI embeddings with LanceDB for vector search. Users can dynamically add web sources to a knowledge base and observe the agent's real-time reasoning process and final answers with source citations.

_rag\_tutorials/agentic\_rag\_with\reasoning · high confidence

Added a new Streamlit-based tutorial application in the \rag\_tutorials/autonomous\_rag\ directory that implements an Autonomous Retrieval-Augmented Generation (RAG) system. The app allows users to upload PDF documents to a PgVector knowledge base and query an AI assistant powered by OpenAI's GPT-4o-mini model, which searches the local knowledge base first and falls back to DuckDuckGo web search if necessary. The entry includes the main application logic (\autorag.py\) and a README with setup instructions and a link to a step-by-step tutorial.

_rag\_tutorials/autonomous\rag · high confidence

A new Streamlit-based application has been added that converts blog posts into audio podcasts. Users input a blog URL and provide API keys for OpenAI, Firecrawl, and ElevenLabs via the sidebar; the app then scrapes the content, generates a concise summary using GPT-4, and converts that summary into an MP3 audio file using ElevenLabs' text-to-speech API, which can be played or downloaded directly in the browser.

_starter\_ai\_agents/ai\_blog\_to\_podcast\agent · high confidence

Adds a new Streamlit-based demo application that uses the Model Context Protocol (MCP) and MCP-Agent to control a Playwright browser via natural language commands. The app allows users to navigate websites, interact with elements, extract content, and take screenshots. It includes configuration files to support both OpenAI and local Ollama/OpenAI-compatible providers, enabling users to run the agent with local models by adjusting the base URL in the config.

_mcp\_ai\_agents/browser\_mcp\agent · high confidence

A new agent skill, Commit Archaeologist, has been added to reconstruct the reasoning behind code changes by analyzing local git history. It identifies the introducing commit, tracks subsequent modifications, detects co-changed files, and extracts intent signals (such as reverts, workarounds, or issue references) from commit messages. The skill runs a local Python script that outputs a structured JSON report, which agents can use to generate readable history summaries and change-risk assessments without making network calls or modifying the repository.

_agent\skills/commit-archaeologist · high confidence

Added a new Corrective RAG tutorial that implements a multi-stage workflow using LangGraph, featuring document retrieval via Qdrant, relevance grading, query transformation, and web search fallback. The application uses Claude 4.5 Sonnet as the primary LLM for analysis and generation, OpenAI embeddings for document vectorization, and Tavily for web search, all orchestrated through a Streamlit UI.

_rag\_tutorials/corrective\rag · high confidence

This location introduces the Earnings Call Analyst Agent, a standalone application that ingests a YouTube earnings call URL to produce a playback-synced analyst workspace. The agent identifies the company and ticker, builds a research pack using SEC filings and Google Search-grounded market news, and generates high-signal investor cards (covering metrics, CFO tone, peer context, and surprises) anchored to specific transcript quotes and timestamps. The FastAPI backend orchestrates the analysis pipeline, while the frontend provides a video player and an insight stream that reveals cards as playback reaches the relevant moments, with a fallback to ADK-powered audio transcription when captions are unavailable.

_advanced\_ai\_agents/single\_agent\_apps/earnings\_call\_analyst\agent · high confidence

A new Streamlit application has been added to the advanced\_llm\_apps directory that demonstrates an iterative quality improvement pattern using GPT-OSS via Groq. The app generates an initial answer using parallel candidate synthesis, then enters a configurable loop (1-3 iterations) where an AI critic identifies flaws and a revision step addresses them, allowing users to observe and track the progressive refinement of the output.

_advanced\_ai\_agents/multi\_agent\_apps/ai\_mental\_wellbeing\_agent, advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\_github, advanced\_llm\_apps/gpt\_oss\_critique\_improvement\loop · high confidence

Added new tutorial scripts and documentation for fine-tuning Google's Gemma 3 and Meta's Llama 3.2 models using the Unsloth library. The Gemma 3 tutorial demonstrates parameter-efficient fine-tuning with 4-bit quantization and LoRA adapters, while the Llama 3.2 tutorial provides a minimal example for efficient fine-tuning on smaller model variants. Both tutorials include runnable Python scripts, README documentation, and configuration guidance for users looking to adapt these models.

_advanced\_llm\_apps/llm\_finetuning\tutorials · high confidence

Added three new self-contained generative UI agent templates to the \generative\_ui\_agents\ directory. The AI Dashboard Canvas Agent uses Google ADK, CopilotKit, and AG-UI to let an LLM populate and manage a persistent canvas of live charts and metrics. The AI Deep Research Agent leverages LangGraph, CopilotKit, and Tavily to plan, search the web, and render tool calls as live workspace cards. The AI Knowledge Explorer provides another generative UI agent pattern. The section also includes a new README explaining the generative UI concept and supported stacks (AG-UI/CopilotKit, Vercel AI SDK, LangChain/LangGraph UI).

_generative\_ui\agents · high confidence

The web application now includes a Generative UI section featuring an AI Financial Coach demo. This update introduces a comprehensive backend API layer for managing AI agents and sandboxed workspaces, including endpoints for provisioning E2B sandboxes, executing commands, reading/writing files, and downloading workspace kits. It also adds MCP (Model Context Protocol) integration capabilities, allowing the app to introspect tools, connect to external MCP servers, and render interactive UI widgets within the builder interface.

_generative\_ui\_agents/ai-mcp-app-builder/apps/web, generative\_ui\_agents/ai-shadcn-component-generator/apps/agent, generative\_ui\agents/generative-ui-starter-project/agent · high confidence

Added a new Streamlit-based GitHub MCP Agent that allows users to explore and analyze GitHub repositories (issues, pull requests, activity) using natural language. The agent leverages the official GitHub MCP Server running via Docker to interact with the GitHub API, requiring an OpenAI API key and a GitHub Personal Access Token for authentication.

_mcp\_ai\_agents/github\_mcp\agent · high confidence

Added comprehensive tutorial examples demonstrating how to build agents with Google ADK using four distinct tool integration patterns: built-in tools (web search and code execution), custom function tools (mathematical calculations and utility operations), third-party integrations (LangChain and CrewAI tools), and Model Context Protocol (MCP) servers. Each example includes ready-to-run agent implementations, configuration files, and documentation to help users understand when and how to use different tool types.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/4\_tool\_using\agent · high confidence

A new tutorial application has been added that implements a Hybrid Search RAG system using Streamlit, RAGLite, and Claude. The app allows users to upload PDF documents, which are processed with semantic and keyword matching, reranked by Cohere, and answered using Claude 3 Opus. It includes a fallback mechanism to Claude 3 Sonnet for general knowledge questions when no relevant documents are found, and supports PostgreSQL, MySQL, or SQLite for storage.

_rag\_tutorials/hybrid\_search\rag · high confidence

Added a new tutorial demonstrating Knowledge Graph-based Retrieval-Augmented Generation (RAG) that enables multi-hop reasoning and verifiable source attribution. The example includes a Streamlit application that uses Ollama for local LLM inference and Neo4j for graph storage, allowing users to extract entities and relationships from documents, traverse connections for complex queries, and receive answers with full provenance tracking.

_rag\_tutorials/knowledge\_graph\_rag\citations · high confidence

The LLM Optimization Tools collection now includes two new demos for reducing API costs. The Headroom Context Optimization demo demonstrates how to use the Headroom library to compress tool outputs and context windows (achieving 50-90% token reduction) via a transparent proxy or framework integrations like LangChain. The Toonify Token Optimization demo introduces a Streamlit app and scripts that convert structured data into the compact TOON format, offering significant token savings compared to standard JSON serialization.

_advanced\_llm\_apps/llm\_optimization\tools · high confidence

A new Streamlit-based agent application has been added to help users estimate term life insurance needs and discover current policy options. Powered by the Agno framework and OpenAI GPT-5, the tool uses an E2B sandbox for deterministic, discounted cash-flow coverage calculations and Firecrawl for live web research on term-life products. Users provide financial details (age, income, debt, etc.) via a minimal intake form, and the agent returns a coverage estimate with a breakdown and up to three product suggestions.

_starter\_ai\_agents/ai\_life\_insurance\_advisor\agent · high confidence

Users can now deploy a multi-agent system that analyzes landing page screenshots and automatically generates improved designs. The team uses a Coordinator/Dispatcher pattern with specialized agents: a UI Critic for visual analysis, a Design Strategist for planning improvements, and a Visual Implementer for generating the new designs. The system supports iterative refinement, versioned artifact tracking, and accessibility checks (WCAG AA) using Google ADK and Gemini 2.5 Flash.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/multimodal\_uiux\_feedback\_agent\team · high confidence

A new terminal-based Notion agent has been added, allowing users to interact with their Notion pages using natural language via the Model Context Protocol (MCP). The agent leverages the Agno framework to provide features such as updating, inserting, and retrieving content, as well as creating blocks and adding comments. It includes persistent conversation context by storing session history in a local SQLite database, enabling multi-turn interactions that remember previous exchanges.

_mcp\_ai\_agents/notion\_mcp\agent · high confidence

Added a new 'chat\_with\_pdf' tutorial directory containing three Streamlit applications: a basic version using OpenAI's API, and two versions using local Llama models (Llama 3 and Llama 3.2) via Ollama. These apps allow users to upload PDF documents, store them in a Chroma vector database, and ask questions about the content using Retrieval Augmented Generation (RAG). A README file is also included with setup instructions and a link to a step-by-step tutorial.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\pdf · high confidence

A new Streamlit-based application has been added that provides a coordinated team of three specialized AI agents (Competitor Analysis, Market Sentiment, and Launch Metrics) to analyze product launches. The app uses the Agno framework with GPT-4o and Firecrawl to gather public web data, presenting results in a tabbed interface with auto-formatted Markdown reports and source citations. Users can input OpenAI and Firecrawl API keys via the sidebar or environment variables to run the analysis.

_advanced\_ai\_agents/multi\_agent\_apps/product\_launch\_intelligence\agent · high confidence

A new local Retrieval-Augmented Generation (RAG) application has been added to the rag\_tutorials/qwen\_local\_rag directory, enabling users to build a reasoning agent using locally hosted Qwen 3, Gemma 3, and DeepSeek models via Ollama. The implementation leverages the Agno v2.0 framework for agent architecture and uses a local Qdrant instance for vector storage, replacing previous cloud-based dependencies. Users can interact with the system through a Streamlit interface to upload PDFs or process web URLs, with configurable options for model selection, RAG mode toggling, similarity thresholds, and optional web search fallback via Exa API.

_rag\_tutorials/qwen\_local\rag · high confidence

Added a new tutorial application in rag\_tutorials/rag\_agent\_cohere that demonstrates a Retrieval-Augmented Generation (RAG) system using the Cohere Command-r model, Qdrant for vector storage, and LangGraph for agent orchestration. The application allows users to upload PDF documents, which are processed and stored in a Qdrant vector store, and enables querying with automatic fallback to DuckDuckGo web search when relevant documents are not found.

_rag\_tutorials/rag\_agent\cohere · high confidence

Added a new Streamlit-based tutorial demonstrating a Retrieval-Augmented Generation (RAG) agent that intelligently routes user queries to one of three specialized Qdrant vector databases (Product Information, Customer Support & FAQ, or Financial Information). The application uses an Agno agent for routing, Langchain for RAG orchestration, and includes a LangGraph-based fallback mechanism with DuckDuckGo search for queries that do not match any database with sufficient confidence.

_rag\_tutorials/rag\_database\routing · high confidence

Adds a new framework-agnostic tutorial that provides a Python script to diagnose LLM and RAG pipeline failures. The tool classifies bugs into 12 reusable patterns (such as retrieval hallucination, chunk boundary errors, or config drift) and suggests minimal structural fixes, saving the diagnosis to a JSON report for post-mortems.

_rag\_tutorials/rag\_failure\_diagnostics\clinic · high confidence

Added a new tutorial application in the rag\_tutorials/rag-as-a-service directory that demonstrates a production-ready Retrieval-Augmented Generation (RAG) pipeline. The application, built with Streamlit, integrates with Ragie.ai for document retrieval and uses the Claude 4.5 Sonnet model (specified as 'claude-sonnet-4-5') for response generation. Users can upload documents via URL, configure API keys for both services, and query the indexed content through a web interface.

_rag\tutorials/rag-as-a-service · high confidence

Added a new Streamlit-based application that allows users to upload a resume and a job description (PDF or TXT) to receive an AI-generated fit score, strengths analysis, and improvement suggestions. The app uses PyMuPDF for file parsing and communicates with a local Ollama instance (defaulting to the llama3 model) via its API to perform the analysis, with results displayed in Markdown and available for download.

_advanced\_llm\_apps/resume\_job\matcher · high confidence

Added a new Voice RAG agent application that enables users to upload PDF documents, query them via text, and receive responses in both text and voice formats. The app uses OpenAI's SDK for text generation and text-to-speech, Qdrant as the vector database for document storage, and Streamlit for the user interface, allowing users to select from multiple voice options and download audio responses.

_voice\_ai\_agents/voice\_rag\openaisdk · high confidence

Two new always-on agents are available in the always\_on\_agents directory. The Hacker News Briefing Agent (AgentScout) monitors Hacker News for high-signal stories about AI agents, MCP, and LLM apps, producing ranked engineering briefs that can be delivered via Gmail or webhooks. The Release Radar Agent scans project dependency manifests (requirements.txt or package.json) against GitHub releases to surface breaking changes, security fixes, and major version upgrades, also supporting opt-in Gmail or webhook delivery. Both agents expose interactive Google ADK interfaces and scheduled FastAPI endpoints with dry-run defaults for safe testing.

_always\_on\agents · high confidence

Added two new Streamlit-based demo applications: a 'Chat with Substack' app that allows users to query a specific Substack newsletter using OpenAI's GPT-4-turbo and the Embedchain library, and a 'Mixture-of-Agents' app that synthesizes responses from multiple LLMs (Qwen, Mixtral, DBRX) via the Together API into a single aggregated answer.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\_substack, starter\_ai\_agents/mixture\_of\agents · high confidence

Added a new Streamlit-based demo application that leverages Firecrawl's FIRE-1 agent to extract structured data from startup websites and uses the Agno framework with OpenAI to generate business analysis. Users can input multiple company URLs to automatically gather information such as company name, description, mission, and product features, followed by an AI-generated summary of the company's value proposition and market opportunities.

_advanced\_ai\_agents/single\_agent\_apps/ai\_startup\_insight\_fire1\agent · high confidence

Added a new Streamlit-based demo application that allows users to chat with their Gmail inbox using Retrieval Augmented Generation (RAG). The app connects to the Gmail API, indexes emails into a Chroma vector database, and uses OpenAI's GPT-4 Turbo to answer questions based on the email content. A corresponding README provides setup instructions for the Google Cloud OAuth credentials and OpenAI API key.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\gmail · high confidence

Adds a new agent skill under agent\_skills/first-reader/scripts that simulates how human readers experience a draft, providing tools to analyze trust signals, simulate skimming, and generate a visual report. The skill includes feed.py to serve text passage-by-passage to prevent AI lookahead, signals.py to measure costly vs. free trust signals, skim.py to simulate a scanner's view, recall.py to quiz memory retention, ask.py to consult reader personas, and room.py to generate an HTML report of the reading session.

_agent\skills/first-reader/scripts · high confidence

Added a new live demo for the Insurance Claim Live Agent Team that enables real-time voice intake using Gemini 3.8 Live. The demo features a browser-based UI (app.js, index.html, styles.css) and a FastAPI backend (server.py) that supports live audio, camera input for evidence photos, and incident sketching. The system integrates with an ADK graph workflow, allowing the AI agent to run background tools like policy lookup, claim packet synchronization, evidence pinning, and sketch generation while maintaining a natural conversation with the claimant.

_voice\_ai\_agents/insurance\_claim\_live\_agent\_team/live\demo · high confidence

A new Streamlit-based application has been added to the rag\_tutorials directory that demonstrates a fully local Retrieval-Augmented Generation (RAG) system. The app uses Google's EmbeddingGemma for vector embeddings and Meta's Llama 3.2 for text generation, both running locally via Ollama. It features an interactive UI where users can add PDF URLs to build a knowledge base, which is indexed using LanceDB for efficient similarity search. The agent retrieves relevant context from this knowledge base to generate streaming responses to user queries.

_rag\_tutorials/agentic\_rag\_embedding\gemma · high confidence

Added a new Streamlit-based tutorial application that enables users to chat with any webpage using a local Llama 3.1 model and Retrieval Augmented Generation (RAG). The app runs entirely offline by loading webpage content, creating Ollama embeddings, and storing them in a Chroma vector store to provide accurate answers based on the retrieved context.

_rag\_tutorials/llama3.1\_local\rag · high confidence

Added a new Streamlit-based multi-agent application that coordinates specialized AI agents (HackerNews, Web Search, and Article Reader) via the Agno \Team\ abstraction to research topics and generate summaries. The location provides two entry points: \research\_agent.py\ for OpenAI models (GPT-4o-mini) and \research\_agent\_llama3.py\ for local Llama 3.2 models via Ollama, along with a README tutorial link.

_advanced\_ai\_agents/multi\_agent\_apps/multi\_agent\researcher · high confidence

Added two new Streamlit applications in the multimodal agent starter kit: a video analysis agent that combines visual understanding with web research using the Gemini 2.5 Flash model, and a reasoning agent for image analysis using the Gemini 2.5 Pro model. These tools allow users to upload video or image files and ask questions, with the agents processing the media and providing comprehensive responses.

_starter\_ai\_agents/multimodal\_ai\agent · high confidence

A new Streamlit-based application has been added that allows users to solve coding problems via text or image upload. The app utilizes a multi-agent architecture: a Gemini vision agent processes uploaded images, an OpenAI o3-mini coding agent generates Python solutions, and an execution agent runs the code in a secure E2B sandbox environment with a 30-second timeout.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/multimodal\_coding\_agent\team · high confidence

A new Streamlit application has been added that orchestrates a team of three specialized AI agents (Visual Design, UX Analysis, and Market Research) using Google's Gemini 2.0 model via the agno framework. Users can upload UI/UX design images to receive comprehensive analysis, including visual element evaluation, user flow assessment, and competitor market insights, with results displayed in a structured, actionable format.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/multimodal\_design\_agent\team · high confidence

A new agent skill has been added to detect when a code change has grown beyond its stated intent. The \scope-creep-detector\ analyzes git diffs (working tree, staged, or branch) against a one-line intent to flag unrelated files, new dependencies, public API renames, config/CI edits, oversized hunks, and formatting-only changes. It outputs a local JSON report with keep, split, or justify recommendations, helping users review broad pull requests or mixed changes without modifying the repository or making network calls.

_agent\skills/scope-creep-detector · high confidence

Added a new tutorial example in the \streaming\_ai\_chatbot\ directory that demonstrates real-time AI streaming and conversation state management using the Motia framework. The example includes a POST \/chat\ API endpoint, an event-driven handler for OpenAI streaming responses, and a conversation state stream to update message status in real-time.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/streaming\_ai\chatbot · high confidence

The OpenAI Agents SDK crash course now includes two new tutorial sections: Tracing & Observability (Tutorial 10) and Voice Agents (Tutorial 11). The Tracing section provides examples for both default automatic tracing (capturing LLM calls, tool usage, and performance metrics automatically) and custom tracing (grouping multi-step workflows, adding business-logic spans, and using trace metadata). The Voice section demonstrates three interaction patterns—static, streaming, and realtime voice processing—showing how to build voice pipelines with speech-to-text, text-to-speech, agent handoffs, and real-time event handling. Each tutorial includes runnable Python scripts, README documentation, and .env.example files to help users get started quickly.

_ai\_agent\_framework\_crash\_course/openai\_sdk\_crash\course · high confidence

Added a new tutorial (Tutorial 7) demonstrating how to use Google ADK plugins for cross-cutting concerns like logging, monitoring, and request modification. The entry includes a Streamlit app (app.py) and agent implementation (agent.py) that register a global plugin on the InMemoryRunner to track agent/tool usage, modify user messages with timestamps, and generate final reports. It also provides an .env.example file for API key configuration and a README explaining plugin lifecycle hooks and use cases.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/7\plugins · high confidence

Added three new crash-course tutorials under the \6\_callbacks\ directory that demonstrate how to use Google ADK callbacks to monitor agent behavior. The \6\_1\_agent\_lifecycle\_callbacks\ tutorial shows how to use \before\_agent\_callback\ and \after\_agent\_callback\ to track agent start/end times and calculate execution duration. The \6\_2\_llm\_interaction\_callbacks\ tutorial demonstrates \before\_model\_callback\ and \after\_model\_callback\ to monitor LLM requests, track token usage, and estimate API costs. The \6\_3\_tool\_execution\_callbacks\ tutorial illustrates \before\_tool\_callback\ and \after\_tool\_callback\ to monitor tool execution, log parameters, and track tool results. Each tutorial includes a Streamlit web interface and a command-line demo agent configured with the \gemini-3-flash-preview\ model.

_ai\_agent\_framework\_crash\_course/google\_adk\_crash\_course/6\callbacks · high confidence

A new Streamlit-based tutorial demonstrates a Retrieval-Augmented Generation (RAG) system using Pydantic AI. The application ingests PDF documents or web pages into an in-memory vector store and uses a typed agent to retrieve relevant chunks. It enforces strict output validation, requiring every answer to include exact source citations and a confidence score. The system also includes a self-refusal mechanism: if the retrieval confidence is below a configurable threshold, the app refuses to answer rather than generating a hallucinated response. It supports both OpenAI and Anthropic models for generation and embeddings, with a local hashing fallback for embeddings when only an Anthropic key is provided.

_rag\_tutorials/agentic\_typed\_rag\pydanticai · high confidence

The client application for the AI Travel Planner agent team has been initialized with a Next.js structure, including a landing page, a trip planning form, and a dashboard for managing plans. User authentication is now supported via email/password using the better-auth library, with routes for sign-in and sign-up. The application exposes API endpoints to persist trip plans to a PostgreSQL database via Prisma, retrieve existing plans, delete plans, and retry failed plan generations by triggering the backend AI agents.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_travel\_planner\_agent\team/client · high confidence

The TripCraft AI travel planner agent team is now available, providing a multi-agent system that generates complete, day-by-day travel itineraries including flights, hotels, dining, and budget optimization. The backend is built on Agno 2.x (upgraded to address [CVE redacted]) and exposes a FastAPI service on port 8001. The system coordinates six specialized agents—Destination Explorer, Hotel Search, Dining, Budget, Flight Search, and Itinerary Specialist—using tools like Exa and Firecrawl for research, and supports configuration via environment variables for API keys and database connections.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_travel\_planner\_agent\team · high confidence

Added a new starter kit for a web scraping AI agent that uses the ScrapeGraphAI library. The kit includes two Streamlit applications: \ai\_scrapper.py\, which allows users to scrape websites using OpenAI models (GPT-4o, GPT-5) via an API key, and \local\_ai\_scrapper.py\, which runs locally using Ollama with the Llama 3.2 model and nomic-embed-text embeddings. A comprehensive README provides setup instructions, use cases (e-commerce, content aggregation, etc.), and documentation links.

_starter\_ai\_agents/web\_scraping\_ai\agent · high confidence

The AI Competitor Intelligence Agent Team application now supports two search endpoints for discovering competitor URLs: the original Perplexity AI - Sonar Pro and a new Exa AI option, allowing users to choose their preferred service via a sidebar selector. The app's entry point is correctly configured to run via \streamlit run competitor\_agent\_team.py\, and a new README provides a step-by-step tutorial link and detailed setup instructions for the required API keys (OpenAI, Firecrawl, and the selected search provider).

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_competitor\_intelligence\_agent\team · high confidence

The AI Data Analysis Agent has been updated to leverage DuckDB for handling uploaded CSV and Excel files, replacing previous data handling methods. This change allows the agent to load data into a local DuckDB table, enabling more efficient SQL-based analysis and complex aggregations via natural language queries. The Streamlit interface remains the same, supporting file uploads and API key configuration, but the underlying engine now provides faster and more robust data processing capabilities.

_starter\_ai\_agents/ai\_data\_analysis\agent · high confidence

The AI Investment Agent has been refactored to utilize the Agno AgentOS framework, replacing the previous Streamlit-based UI with a native AgentOS playground interface. The agent now uses the GPT-5.2 model (specifically gpt-5.2-2025-12-11) and integrates YFinance tools for stock analysis. Users can run the agent via \python investment\_agent.py\ and interact with it through the provided web UI, with optional connection to the AgentOS Control Plane for monitoring.

_advanced\_ai\_agents/single\_agent\_apps/ai\_investment\agent · high confidence

The AI Startup Trend Analysis Agent has switched its underlying language model from Claude 3.5 Sonnet to Google's Gemini 2.5 Flash. Consequently, users must now provide a Google API key rather than an Anthropic API key to run the application. The agent's workflow remains the same, using DuckDuckGo for news collection, Newspaper4k for summarization, and the new Gemini model for trend analysis, all presented via the existing Streamlit interface.

_starter\_ai\_agents/ai\_startup\_trend\_analysis\agent · high confidence

The AI Teaching Agent Team application has been updated to use the Agno framework (migrating from phidata), introducing type-safe run outputs via \RunOutput\ and renaming internal agent roles (e.g., KnowledgeBuilder to Professor, RoadmapArchitect to Academic Advisor). The Streamlit interface now explicitly manages OpenAI, Composio, and SerpAPI keys, orchestrating four specialized agents to generate a knowledge base, learning roadmap, resource list, and practice materials as Google Docs. A new README provides a comprehensive step-by-step tutorial and configuration guide for users.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_teaching\_agent\team · high confidence

The Deepseek Local RAG Agent tutorial has been updated to switch the embedding model to Snowflake Arctic Embed and use Llama 3.2 for web search capabilities. The application now supports dual operation modes (local chat and RAG-enhanced reasoning) with configurable similarity thresholds and optional Exa AI web search fallback. Users can select between Deepseek R1 1.5b and 7b models via the Streamlit interface, with clear instructions for setting up Ollama, Qdrant Cloud, and Exa AI API keys.

_rag\_tutorials/deepseek\_local\_rag\agent · high confidence

The AI Legal Agent Team application has been updated to use the GPT-5 model for its cloud-based analysis, replacing the previous GPT-4o configuration. Additionally, a new local deployment option has been introduced in the \local\_ai\_legal\_agent\_team\ subdirectory, allowing users to run the agent team entirely offline using Ollama (specifically \llama3.1:8b\) and a local Qdrant instance, eliminating the need for external API keys for model inference.

_advanced\_ai\_agents/multi\_agent\_apps/agent\_teams/ai\_legal\_agent\team · high confidence

The local RAG agent tutorial has been updated to use Agno v2.0, replacing the previous Phidata implementation. It now leverages the Agno Knowledge class for document management and exposes an interactive web-based UI via the AgentOS interface at localhost:7777. The application continues to use Llama 3.2 via Ollama and Qdrant for local vector search, with no external API dependencies required.

_rag\_tutorials/local\_rag\agent · high confidence

The multi-agent Streamlit application has been renamed from 'multi\_mcp\_agent\_forge' to 'multi\_mcp\_agent\_router' to better reflect its core functionality of routing user queries to specialized AI agents. This change updates the directory name, the main application script (agent\_forge.py), and the documentation (README.md) to align with the new naming convention, while preserving the existing behavior of routing requests to specialized agents like the Code Reviewer, Security Auditor, Researcher, and BIM Engineer.

_mcp\_ai\_agents/multi\_mcp\_agent\router · high confidence

The Vision RAG tutorial application has been updated to leverage the latest AI models for improved multimodal retrieval and generation. The system now uses Cohere's Embed-4 model for generating dense vector embeddings of images and PDF pages, replacing previous embedding approaches. For the generation stage, the app now utilizes Google's Gemini 2.5 Flash model to analyze retrieved visual content and answer user questions. The Streamlit interface and underlying logic have been adjusted to support these new models, including specific handling for PDF page extraction and embedding via PyMuPDF.

_rag\_tutorials/vision\rag · high confidence

The YouTube chat app now uses the \youtube-transcript-api\ v1.2+ interface, requiring explicit API instantiation and handling \FetchedTranscript\ objects instead of the previous list-of-dicts format. This change is accompanied by enhanced error handling that provides specific, user-friendly messages for issues like unavailable videos, disabled subtitles, or parsing errors. Additionally, the application's session state management has been refined to ensure transcripts are fetched only once per video URL, chat history is preserved during the same session, and is correctly cleared when switching to a new video, improving reliability and user experience.

_advanced\_llm\_apps/chat\_with\_X\_tutorials/chat\_with\_youtube\videos · high confidence

The xAI Finance Agent application has been refactored to utilize the AgentOS framework, replacing the previous Streamlit-based interface with a managed AgentOS deployment. Users can now run the agent via a standard Python script that initializes the AgentOS instance and serves the application, enabling integration with the AgentOS Control Plane for monitoring and management. The agent continues to leverage xAI's Grok model for financial analysis, supported by YFinance and DuckDuckGo tools, and includes debug mode enabled by default.

_starter\_ai\_agents/xai\_finance\agent · high confidence

The autonomous visualization workflow in the 3D PyGame agent now reliably executes code on Trinket.io. A previous bug caused the browser agent to navigate to the editor but fail to input the generated PyGame script. The code diff updates the browser agent's task instruction to explicitly select all existing content and paste the specific generated code, ensuring the visualization runs automatically as intended.

_advanced\_ai\_agents/autonomous\_game\_playing\_agent\_apps/ai\_3dpygame\r1 · high confidence

Added deterministic evaluation suite for the first-reader skill; Added evaluation suite for the commit-archaeologist skill; Added tests for the scope-creep-detector skill.

Added explicit requirements.txt, pyproject.toml, and package.json files across numerous AI agent and LLM application directories (including autonomous game playing, multi-agent teams, single agents, and chat tutorials). This ensures reproducible environments by pinning or specifying version ranges for core libraries such as agno (\>=2.2.10), streamlit, openai, and google-adk, alongside framework-specific dependencies like Next.js, React, and FastAPI.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 44.

• Code Health 55
• Architecture 91
• Maturity 72
• Readiness 30
• Security 66
• Domain Modelling 100
• Accessibility 44

• 300 commits — 200 feature/other, 100 fixes

• (repo) — 80 commits
• (root) — 38 commits
• advanced_ai_agents/multi_agent_apps — 23 commits
• agent_skills/advisor-orchestrator-worker — 20 commits
• voice_ai_agents/insurance_claim_live_agent_team — 11 commits
• advanced_ai_agents/single_agent_apps — 7 commits
• agent_skills/first-reader — 7 commits
• generative_ui_agents/ai-knowledge-explorer — 6 commits
• advanced_llm_apps/llm_apps_with_memory_tutorials — 5 commits
• agent_skills/README.md — 5 commits
• agent_skills/dependency-doctor — 5 commits
• agent_skills/project-graveyard — 5 commits
• awesome_agent_skills/self-improving-agent-skills — 5 commits
• agent_skills/scope-creep-detector — 4 commits
• agent_skills/self-improving-agent-skills — 4 commits
• agent_skills/thinking-out-loud — 4 commits
• ai_agent_framework_crash_course/openai_sdk_crash_course — 4 commits
• awesome_agent_skills/advisor-executor-worker — 4 commits
• advanced_ai_agents/autonomous_game_playing_agent_apps — 3 commits
• agent_skills/commit-archaeologist — 3 commits

• fix: Fix AI travel agent setup path
• fix: Fix Beifong FAISS search to convert L2 distance to cosine similarity
• fix: Fix GTM email campaign success-report and journalist agno 2.x Team API
• fix: Fix beifong X scraper name capture, engagement 500, and dropped sentiment queue
• fix: Fix broken README run commands for AQI, real estate, and Voice RAG
• fix: Fix broken paths in ai_music_generator_agent README
• fix: Fix broken retrieval/setup in four RAG tutorials (#1051)
• fix: Fix consultant tool schema, customer-support memory, and governance approval bypass (#1050)
• fix: Fix domain research setup path
• fix: Fix earnings analyst ADK auth detection
• fix: Fix issue #1027: Added tokenizer and saved the model at the end (#1033)
• fix: Fix missing spaces in research_agent instructions
• fix: Fix misspelled multimodal_agent.py filename
• fix: Fix podcast script failure check using or instead of and
• fix: Fix project-graveyard --redact corrupting state and faking relapse verdicts
• fix: Fix release_radar version extraction and customer-support voice model (#1020)
• fix: Fix renamed/transferred repo URLs across template docs
• fix: Fix six starter/advanced_llm Python apps that crash or corrupt data
• fix: Fix three broken multi-agent apps (devpulse import/key, financial-coach CSV guard, design-team agno kwarg) (#1016)
• fix: Fix three crash-course example scripts that crash on run (#1014)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Shubhamsaboo/awesome-llm-apps was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.