A comprehensive collection of 16 production-ready AI agent implementations built with Phidata, covering diverse use cases from data analysis and financial advisory to creative content generation and multi-agent orchestration.
- Overview
- What is Phidata?
- Repository Structure
- Agent Catalog
- Prerequisites
- Installation & Setup
- Environment Configuration
- Running Agents
- Agent Details
- Use Cases & Applications
- Architecture Patterns
- Contributing
- Troubleshooting
- Resources
- License
AI Agent Starter Kit is a curated collection of AI agent implementations that demonstrate the power and flexibility of the Phidata framework. Each agent is a self-contained, production-ready example that showcases different capabilities — from single-purpose specialized agents to complex multi-agent systems using the Mixture of Agents (MoA) architecture.
This repository serves as both a learning resource for developers getting started with AI agents and a reference implementation library for building sophisticated agentic systems. Whether you're building a financial advisor, automating content creation, or orchestrating teams of specialized agents, you'll find a relevant starting point here.
Phidata is a Python framework for building multi-modal AI agents with memory, knowledge bases, tools, and reasoning capabilities. It simplifies the process of creating production-grade agents by providing:
- Simple & Elegant API — Build powerful agents with minimal code
- Multi-Modal Support — Handle text, images, audio, and video
- Built-in Tools — Pre-integrated web search, databases, APIs, and more
- Agent Teams — Orchestrate multiple agents working together
- Memory & Knowledge — Long-term storage and retrieval from vector databases
- Beautiful Agent UI — Chat interface for interacting with your agents
- Monitoring & Debugging — Track sessions, evaluate performance, optimize workflows
Unlike other frameworks (LangChain, LlamaIndex), Phidata focuses on production readiness with minimal abstraction overhead, making it ideal for rapidly deploying AI agent systems.
AI-Agent-Starter/
├── ai_blog_to_podcast_agent/ # Content transformation agent
├── ai_breakup_recovery_agent/ # Mental health support agent
├── ai_data_analysis_agent/ # Data analytics and insights
├── ai_data_visualisation_agent/ # Chart and graph generation
├── ai_life_insurance_advisor_agent/ # Financial advisory
├── ai_medical_imaging_agent/ # Healthcare diagnostics
├── ai_meme_generator_agent_browseruse/ # Creative content with browser automation
├── ai_music_generator_agent/ # Music composition
├── ai_reasoning_agent/ # Complex reasoning and logic
├── ai_startup_trend_analysis_agent/ # Market research and trends
├── ai_travel_agent/ # Trip planning and recommendations
├── mixture_of_agents/ # Multi-agent orchestration (MoA)
├── multimodal_ai_agent/ # Text, image, audio processing
├── opeani_research_agent/ # Web research and synthesis
├── web_scrapping_ai_agent/ # Data extraction and scraping
└── xai_finance_agent/ # Advanced financial analysis
Each directory contains:
- Agent implementation (
agent.pyor similar entry point) - Requirements file (
requirements.txt) - Configuration samples (
.env.examplewhere applicable) - Documentation (inline comments and usage examples)
| Agent | Description | Key Tools |
|---|---|---|
| Blog to Podcast | Converts written articles into podcast-style audio scripts | Text-to-speech, NLP summarization |
| Meme Generator | Creates contextual memes using browser automation | BrowserUse, image search, caption generation |
| Music Generator | Composes original music based on text prompts | Audio synthesis APIs, music theory |
| Agent | Description | Key Tools |
|---|---|---|
| Data Analysis | Performs statistical analysis and data exploration | Pandas, NumPy, SQL querying |
| Data Visualization | Generates charts, graphs, and dashboards | Matplotlib, Plotly, Seaborn |
| Startup Trend Analysis | Analyzes market trends and startup ecosystems | Web scraping, sentiment analysis |
| Agent | Description | Key Tools |
|---|---|---|
| Life Insurance Advisor | Provides personalized insurance recommendations | Risk assessment, financial calculators |
| Finance Agent (xAI) | Advanced financial analysis and forecasting | Yahoo Finance API, real-time data feeds |
| Agent | Description | Key Tools |
|---|---|---|
| Reasoning Agent | Solves complex logical problems step-by-step | Chain-of-thought prompting, logic trees |
| Research Agent (OpenAI) | Conducts web research and synthesizes findings | DuckDuckGo search, web scraping |
| Web Scraping Agent | Extracts structured data from websites | BeautifulSoup, Selenium, Playwright |
| Agent | Description | Key Tools |
|---|---|---|
| Medical Imaging | Analyzes medical images for diagnostics | Image classification, computer vision |
| Breakup Recovery | Provides emotional support and guidance | Sentiment analysis, conversation memory |
| Agent | Description | Key Tools |
|---|---|---|
| Travel Agent | Plans trips, recommends destinations, books itineraries | Google Places API, flight/hotel APIs |
| Agent | Description | Key Tools |
|---|---|---|
| Mixture of Agents (MoA) | Orchestrates multiple LLMs in a layered architecture for superior output quality | Multi-model coordination, response aggregation |
| Multimodal Agent | Processes text, images, audio, and video simultaneously | Vision APIs, speech recognition, OCR |
Before running any agent, ensure you have:
- Python 3.9 or higher (Python 3.10+ recommended)
- pip package manager
- Virtual environment tool (
venvorconda) - API Keys for required services:
- OpenAI API key (required for most agents)
- Additional service keys depending on the agent (e.g., Google Cloud, Anthropic, Groq)
git clone https://github.com/fiv3fingers/AI-Agent-Starter.git
cd AI-Agent-StarterNavigate to the agent directory you want to use:
cd ai_data_analysis_agent # Example: Data Analysis AgentUsing venv:
python -m venv venvActivate the virtual environment:
-
Windows (Command Prompt):
venv\Scripts\activate
-
Windows (PowerShell):
venv\Scripts\Activate.ps1
-
macOS/Linux:
source venv/bin/activate
pip install -r requirements.txtMost agents require API keys and environment variables. Create a .env file in the agent's directory:
# OpenAI Configuration (required for most agents)
OPENAI_API_KEY=sk-your-openai-api-key-here
# Phidata Configuration (optional, for monitoring)
PHI_API_KEY=your-phidata-api-key-here
PHI_MONITORING=false
# Agent-Specific Keys (add as needed)
ANTHROPIC_API_KEY=your-anthropic-key
GROQ_API_KEY=your-groq-key
GOOGLE_API_KEY=your-google-key
# Debug Mode (set to true for detailed logs)
PHI_DEBUG=false- OpenAI: https://platform.openai.com/api-keys
- Phidata: https://phidata.app (for monitoring dashboard)
- Anthropic: https://console.anthropic.com
- Groq: https://console.groq.com
- Google Cloud: https://console.cloud.google.com
After completing setup and configuration:
# Ensure virtual environment is activated
python agent.py # or main.py, depending on the agentcd ai_data_analysis_agent
python -m venv venv
venv\Scripts\activate # Windows
pip install -r requirements.txt
# Add OPENAI_API_KEY to .env
python agent.pycd mixture_of_agents
python -m venv venv
source venv/bin/activate # macOS/Linux
pip install -r requirements.txt
# Configure API keys in .env
python moa_agent.pyMany agents support interactive mode where you can chat with them:
from phi.agent import Agent
from phi.model.openai import OpenAIChat
agent = Agent(
model=OpenAIChat(id="gpt-4"),
markdown=True
)
# Start interactive session
agent.print_response("Analyze this dataset for trends...", stream=True)Purpose: Transforms written blog posts into engaging podcast-style audio scripts.
Use Case: Content creators who want to repurpose written content into audio format for podcast distribution.
Key Features:
- Extracts key points from articles
- Generates conversational script with intro/outro
- Optimizes for spoken delivery (removes jargon, adds transitions)
- Optional text-to-speech integration
Technologies: Phidata, OpenAI GPT-4, NLP summarization, TTS APIs
Purpose: Provides empathetic emotional support and practical advice for relationship recovery.
Use Case: Mental health support chatbot for users going through difficult breakups.
Key Features:
- Empathetic conversation with sentiment analysis
- Personalized recovery roadmap and milestones
- Memory of user's journey across sessions
- Resources and coping strategies
Technologies: Phidata, conversation memory, sentiment analysis, long-term storage
Purpose: Performs statistical analysis, generates insights, and answers questions about datasets.
Use Case: Business analysts, data scientists, and researchers who need quick exploratory data analysis.
Key Features:
- Loads CSV, Excel, SQL databases
- Performs descriptive statistics, correlations, trend detection
- Generates natural language insights
- Suggests visualizations and next steps
Technologies: Phidata, Pandas, NumPy, SQL tools
Purpose: Creates publication-quality charts, graphs, and dashboards from data.
Use Case: Quickly generate visualizations for reports, presentations, or web applications.
Key Features:
- Supports bar, line, scatter, pie, heatmap, and more
- Automatic chart type selection based on data
- Customizable styling (colors, labels, legends)
- Exports to PNG, SVG, HTML
Technologies: Phidata, Matplotlib, Plotly, Seaborn
Purpose: Provides personalized life insurance recommendations based on user profile.
Use Case: Financial advisory chatbot for insurance comparison and selection.
Key Features:
- Collects user demographics and financial info
- Calculates coverage needs using industry formulas
- Compares policy types (term, whole, universal)
- Generates recommendation report
Technologies: Phidata, financial calculation tools, risk assessment
Purpose: Analyzes medical images (X-rays, MRIs, CT scans) for diagnostic assistance.
Use Case: Healthcare professionals needing second opinions or automated initial screenings.
Key Features:
- Image classification (pneumonia, fractures, tumors)
- Heatmap overlay showing areas of concern
- Confidence scores and diagnostic suggestions
- HIPAA-compliant processing
Technologies: Phidata, computer vision APIs, medical image models
Purpose: Creates contextual memes by searching for images and adding captions.
Use Case: Social media managers, content marketers, or anyone needing quick viral content.
Key Features:
- Uses browser automation to search for relevant images
- Generates witty captions based on context
- Automatically overlays text on images
- Exports ready-to-share meme files
Technologies: Phidata, BrowserUse/Playwright, image processing, GPT-4 Vision
Purpose: Composes original music based on text descriptions.
Use Case: Content creators needing royalty-free background music for videos or podcasts.
Key Features:
- Text-to-music generation (e.g., "upbeat jazz piano")
- Customizable tempo, key, mood, instruments
- Exports to MP3, WAV, MIDI
- Integration with music APIs (e.g., Suno, MusicGen)
Technologies: Phidata, music synthesis APIs, audio processing
Purpose: Solves complex logical puzzles, math problems, and reasoning tasks.
Use Case: Educational tools, coding interview prep, logic puzzle solving.
Key Features:
- Step-by-step chain-of-thought reasoning
- Handles math, logic, word problems
- Explains reasoning process transparently
- Supports multi-step problem decomposition
Technologies: Phidata, advanced prompting, structured reasoning
Purpose: Analyzes startup ecosystems, funding trends, and market opportunities.
Use Case: VCs, entrepreneurs, and market researchers tracking innovation trends.
Key Features:
- Scrapes Crunchbase, PitchBook, AngelList
- Identifies emerging sectors and geographic hotspots
- Generates trend reports with visualizations
- Tracks funding rounds, valuations, exits
Technologies: Phidata, web scraping, sentiment analysis, data visualization
Purpose: Plans trips, recommends destinations, and books itineraries.
Use Case: Travelers needing personalized trip planning assistance.
Key Features:
- Multi-destination trip planning
- Budget optimization
- Activity and restaurant recommendations
- Integration with booking APIs (flights, hotels, tours)
Technologies: Phidata, Google Places API, travel booking APIs
Purpose: Orchestrates multiple LLMs in a layered architecture to produce superior outputs.
Use Case: High-stakes applications requiring the best possible answer quality (research, legal analysis, critical decisions).
Key Features:
- Multi-layer architecture with proposer and aggregator agents
- Leverages diverse LLMs (GPT-4, Claude, Gemini, Llama, Mixtral)
- Iterative refinement for increasingly accurate responses
- Outperforms single-model approaches on benchmarks
Technologies: Phidata, OpenAI, Anthropic, Google Gemini, multi-agent orchestration
Architecture:
Layer 1 (Proposers) → Layer 2 (Refiners) → Layer 3 (Aggregator) → Final Output
├─ GPT-4 ├─ Claude └─ Gemini
├─ Claude ├─ GPT-4
├─ Llama └─ Mixtral
└─ Mixtral
Purpose: Processes and generates text, images, audio, and video simultaneously.
Use Case: Applications requiring cross-modal understanding (e.g., video analysis with Q&A, image captioning with audio narration).
Key Features:
- Accepts multiple input modalities
- Cross-modal reasoning (e.g., describe image + search related audio)
- Generates outputs in multiple formats
- Unified conversation across modalities
Technologies: Phidata, GPT-4 Vision, Whisper, DALL-E, multimodal APIs
Purpose: Conducts comprehensive web research and synthesizes findings into reports.
Use Case: Researchers, journalists, students needing thorough information gathering.
Key Features:
- Multi-query web search (DuckDuckGo, Bing)
- Crawls and extracts content from web pages
- Synthesizes findings into structured reports
- Cites sources with links
Technologies: Phidata, DuckDuckGo tool, web scraping, summarization
Purpose: Extracts structured data from websites at scale.
Use Case: Data collection for research, price monitoring, lead generation.
Key Features:
- Headless browser automation
- Handles JavaScript-rendered content
- Exports to CSV, JSON, databases
- Rate limiting and error handling
Technologies: Phidata, BeautifulSoup, Selenium, Playwright
Purpose: Advanced financial analysis using real-time market data.
Use Case: Traders, investors, financial analysts needing data-driven insights.
Key Features:
- Real-time stock prices, news, and sentiment
- Technical analysis (moving averages, RSI, MACD)
- Portfolio optimization and risk assessment
- Generates investment reports
Technologies: Phidata, Yahoo Finance API, yfinance, financial modeling
- Learn Phidata — Study production-ready agent implementations
- Rapid Prototyping — Fork agents as starting points for custom projects
- Multi-Agent Systems — Understand MoA architecture and agent orchestration
- Tool Integration — See how to connect agents to APIs, databases, and external services
- Customer Support — Deploy breakup recovery or advisory agents as chatbots
- Data Operations — Automate data analysis and reporting with data agents
- Content Marketing — Use meme and music generators for social media content
- Financial Services — Offer AI-powered insurance or investment advisory
- Agent Benchmarking — Compare single-agent vs. multi-agent performance
- Multimodal AI — Experiment with cross-modal reasoning and generation
- Healthcare AI — Explore medical imaging diagnostics with AI assistance
- AI Experimentation — Build and modify agents without infrastructure complexity
- Portfolio Projects — Showcase AI agent projects to employers
- Skill Building — Learn Python, LLM integration, API usage, and agent design
This repository demonstrates several key architectural patterns:
Pattern: One agent, one task.
Example: Data Analysis Agent, Music Generator Agent
When to use: Clear, well-defined tasks with minimal cross-domain dependencies.
Pattern: One agent with multiple tool integrations.
Example: Research Agent (web search + scraping + summarization)
When to use: Tasks requiring access to multiple external services.
Pattern: Multiple LLMs work in layers to refine outputs.
Example: Mixture of Agents directory
When to use: High-stakes applications where answer quality is critical.
Pattern: Agent processes multiple data types (text, image, audio).
Example: Multimodal AI Agent
When to use: Applications requiring cross-modal understanding.
Pattern: Agent remembers conversation history and user context.
Example: Breakup Recovery Agent
When to use: Long-term interactions requiring personalization.
Contributions are welcome! If you've built a useful Phidata agent or improved an existing one, we'd love to include it.
- Fork the repository
- Create a new branch (
git checkout -b feature/new-agent) - Add your agent in a new directory with:
- Agent implementation file
requirements.txt.env.example(if needed)- Inline documentation
- Update this README with agent details in the catalog
- Submit a pull request
- Ensure code is well-documented with docstrings
- Include a
requirements.txtwith pinned versions - Test the agent end-to-end before submission
- Follow existing directory structure conventions
- Add usage examples in comments
Issue: pip install fails with dependency conflicts
Solution: Ensure you're using Python 3.9+ and upgrade pip: pip install --upgrade pip
Issue: OPENAI_API_KEY not found
Solution: Create a .env file in the agent directory with your API key. Ensure it's loaded using python-dotenv.
Issue: Agent runs but returns low-quality responses
Solution: Try using a more powerful model (e.g., gpt-4 instead of gpt-3.5-turbo) or increase max_tokens.
Issue: ModuleNotFoundError: No module named 'phi'
Solution: Install Phidata: pip install phidata
Issue: Agent is slow or times out
Solution: Check your API rate limits, reduce input size, or enable streaming responses.
- Phidata Documentation: https://docs.phidata.com
- Phidata GitHub Issues: https://github.com/phidatahq/phidata/issues
- Community Discord: https://discord.gg/phidata (check official site)
- Stack Overflow: Tag questions with
phidataandai-agents
- Mixture-of-Agents Paper (Wang et al., 2024)
- Together AI MoA Implementation
- Multi-Agent Systems Overview
- Building AI Agents with Phidata (GeeksforGeeks)
- Phidata Tutorial (Build5Nines)
- AI Agent Design Patterns
This project is licensed under the MIT License — see the LICENSE file for details.
You are free to use, modify, and distribute these agents for personal or commercial purposes, with attribution.
- Phidata Team — For building an incredible AI agent framework
- OpenAI — For GPT models powering most agents
- Together AI — For pioneering the Mixture of Agents approach
- Open Source Community — For contributions, feedback, and support
If you find this repository helpful, please consider giving it a ⭐️ on GitHub!
Built with ❤️ by the AI Agent community