500-ai-agents-projects-catalog

name	500-ai-agents-projects-catalog
description	Comprehensive catalog of 500+ AI agent use cases across industries with open-source implementations and framework examples
triggers	["show me AI agent use cases for healthcare","find AI agent projects for my industry","what are examples of CrewAI implementations","browse AI agent applications in finance","find open source AI agent projects","show me langgraph agent examples","what AI agents exist for customer service","explore autogen framework use cases"]

500 AI Agents Projects Catalog

Skill by ara.so — AI Agent Skills collection.

Overview

The 500 AI Agents Projects is a curated collection of AI agent use cases across various industries including healthcare, finance, education, retail, transportation, manufacturing, and more. It provides:

• Industry-categorized use cases: AI agents organized by sector (Healthcare, Finance, Education, Customer Service, Retail, etc.)
• Framework-specific examples: Use cases organized by AI agent frameworks (CrewAI, AutoGen, Agno, LangGraph)
• Open-source implementations: Direct links to working GitHub repositories for each use case
• Practical applications: Real-world examples showing how AI agents solve specific problems

Installation

This is a reference repository, not an installable package. To use it:

# Clone the repository
git clone https://github.com/ashishpatel26/500-AI-Agents-Projects.git
cd 500-AI-Agents-Projects

# Browse the README for use cases
cat README.md

Repository Structure

The repository is organized into:

1. Industry Use Case Table: Main table with 500+ use cases categorized by industry
2. Framework-Specific Sections: Use cases organized by framework (CrewAI, AutoGen, Agno, LangGraph)
3. Industry MindMap: Visual representation of industries using AI agents

Finding Use Cases

By Industry

The main use case table categorizes agents by industry:

• Healthcare: Health diagnostics, medical report analysis, disease monitoring
• Finance: Trading bots, fraud detection, risk assessment
• Education: Virtual tutors, personalized learning, grading automation
• Customer Service: 24/7 chatbots, ticket routing, sentiment analysis
• Retail: Product recommendations, inventory management, price optimization
• Transportation: Route optimization, autonomous delivery, fleet management
• Manufacturing: Quality control, predictive maintenance, process monitoring
• Real Estate: Property pricing, market analysis, virtual tours
• Agriculture: Crop monitoring, yield prediction, pest detection
• Energy: Demand forecasting, grid optimization, consumption analysis
• Entertainment: Content personalization, recommendation engines
• Legal: Document review, contract analysis, compliance checking
• HR: Recruitment, candidate matching, employee engagement
• Hospitality: Travel planning, booking optimization, guest services
• Gaming: Game companions, strategy assistance, player matching
• Cybersecurity: Threat detection, vulnerability scanning, incident response
• E-commerce: Personal shopping, cart optimization, dynamic pricing
• Supply Chain: Logistics optimization, inventory forecasting, route planning

By Framework

CrewAI Examples

CrewAI is a framework for orchestrating role-playing, autonomous AI agents:

# Example: Email Auto Responder (Communication)
# Repository: crewAI-examples/flows/email_auto_responder_flow

from crewai import Agent, Task, Crew

# Define agents
email_classifier = Agent(
    role="Email Classifier",
    goal="Classify incoming emails by priority and category",
    backstory="Expert at email triage and organization"
)

response_writer = Agent(
    role="Response Writer",
    goal="Draft appropriate email responses",
    backstory="Professional communication specialist"
)

# Define tasks
classify_task = Task(
    description="Classify the email: {email_content}",
    agent=email_classifier
)

respond_task = Task(
    description="Write response for classified email",
    agent=response_writer
)

# Create crew
crew = Crew(
    agents=[email_classifier, response_writer],
    tasks=[classify_task, respond_task]
)

# Execute
result = crew.kickoff(inputs={"email_content": "..."})

CrewAI Use Cases in Catalog:

• Email Auto Responder Flow (Communication)
• Meeting Assistant Flow (Productivity)
• Lead Score Flow (Sales)
• Marketing Strategy Generator (Marketing)
• Job Posting Generator (Recruitment)
• Recruitment Workflow (HR)

AutoGen Examples

AutoGen enables development of LLM applications using multiple agents:

# Example: Multi-agent collaboration
# Common pattern in AutoGen projects

import autogen

config_list = autogen.config_list_from_json(
    "OAI_CONFIG_LIST",
    filter_dict={"model": ["gpt-4"]}
)

# Create assistant agent
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list}
)

# Create user proxy agent
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"}
)

# Initiate conversation
user_proxy.initiate_chat(
    assistant,
    message="Analyze this dataset and provide insights"
)

LangGraph Examples

LangGraph is used for building stateful, multi-actor applications with LLMs:

# Example: Customer Support Agent
# Repository: GenAI_Agents/customer_support_agent_langgraph.ipynb

from langgraph.graph import StateGraph, END
from langchain_core.messages import HumanMessage

# Define state
class AgentState(TypedDict):
    messages: list[HumanMessage]
    next_step: str

# Define nodes
def classify_query(state):
    """Classify customer query"""
    # Classification logic
    return {"next_step": "technical" if is_technical else "general"}

def technical_support(state):
    """Handle technical queries"""
    # Technical support logic
    return {"messages": state["messages"] + [response]}

def general_support(state):
    """Handle general queries"""
    # General support logic
    return {"messages": state["messages"] + [response]}

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("classify", classify_query)
workflow.add_node("technical", technical_support)
workflow.add_node("general", general_support)

workflow.set_entry_point("classify")
workflow.add_conditional_edges(
    "classify",
    lambda x: x["next_step"],
    {"technical": "technical", "general": "general"}
)
workflow.add_edge("technical", END)
workflow.add_edge("general", END)

app = workflow.compile()

# Run
result = app.invoke({
    "messages": [HumanMessage(content="My app crashed")],
    "next_step": ""
})

Common Patterns

Pattern 1: Finding Relevant Use Cases

# Search the catalog programmatically
import requests
import re

def find_use_cases_by_industry(industry: str):
    """Find AI agent use cases for a specific industry"""
    url = "https://raw.githubusercontent.com/ashishpatel26/500-AI-Agents-Projects/main/README.md"
    response = requests.get(url)
    
    # Parse markdown table
    lines = response.text.split('\n')
    use_cases = []
    
    for line in lines:
        if industry.lower() in line.lower() and '|' in line:
            parts = [p.strip() for p in line.split('|')]
            if len(parts) > 4:
                use_cases.append({
                    'name': parts[1],
                    'industry': parts[2],
                    'description': parts[3],
                    'github_link': extract_github_link(parts[4])
                })
    
    return use_cases

def extract_github_link(markdown_link: str) -> str:
    """Extract GitHub URL from markdown link"""
    match = re.search(r'https://github\.com/[^\)]+', markdown_link)
    return match.group(0) if match else None

# Usage
healthcare_agents = find_use_cases_by_industry("Healthcare")
for agent in healthcare_agents:
    print(f"{agent['name']}: {agent['description']}")
    print(f"GitHub: {agent['github_link']}\n")

Pattern 2: Exploring Framework Examples

def get_framework_examples(framework: str):
    """Get examples for a specific framework (CrewAI, AutoGen, LangGraph)"""
    url = "https://raw.githubusercontent.com/ashishpatel26/500-AI-Agents-Projects/main/README.md"
    response = requests.get(url)
    
    # Find framework section
    content = response.text
    framework_section = re.search(
        f'### \\*\\*Framework Name\\*\\*: \\*\\*{framework}\\*\\*(.*?)(?=###|$)',
        content,
        re.DOTALL | re.IGNORECASE
    )
    
    if framework_section:
        section_text = framework_section.group(1)
        # Parse table rows
        examples = []
        for line in section_text.split('\n'):
            if '|' in line and 'Use Case' not in line and '---' not in line:
                parts = [p.strip() for p in line.split('|')]
                if len(parts) > 3:
                    examples.append({
                        'use_case': parts[1],
                        'industry': parts[2],
                        'description': parts[3]
                    })
        return examples
    return []

# Usage
crewai_examples = get_framework_examples("CrewAI")
print(f"Found {len(crewai_examples)} CrewAI examples")

Pattern 3: Building Custom Agent from Catalog

# Example: Implementing a Healthcare AI Agent based on catalog

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
import os

class HealthInsightsAgent:
    """
    Based on: HIA (Health Insights Agent)
    Repository: github.com/harshhh28/hia
    """
    
    def __init__(self):
        self.llm = OpenAI(
            temperature=0,
            api_key=os.getenv("OPENAI_API_KEY")
        )
        self.memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
        self.tools = self._create_tools()
        self.agent = initialize_agent(
            self.tools,
            self.llm,
            agent="conversational-react-description",
            memory=self.memory
        )
    
    def _create_tools(self):
        return [
            Tool(
                name="Analyze Medical Report",
                func=self.analyze_report,
                description="Analyzes medical reports and extracts key insights"
            ),
            Tool(
                name="Health Recommendations",
                func=self.get_recommendations,
                description="Provides health recommendations based on analysis"
            )
        ]
    
    def analyze_report(self, report_text: str) -> str:
        """Analyze medical report"""
        # Implementation based on HIA project
        prompt = f"Analyze this medical report and extract key findings:\n{report_text}"
        return self.llm(prompt)
    
    def get_recommendations(self, findings: str) -> str:
        """Generate health recommendations"""
        prompt = f"Based on these findings, provide health recommendations:\n{findings}"
        return self.llm(prompt)
    
    def chat(self, message: str) -> str:
        """Main chat interface"""
        return self.agent.run(message)

# Usage
agent = HealthInsightsAgent()
response = agent.chat("Analyze my recent blood test results")
print(response)

Pattern 4: Multi-Industry Agent System

# Example: Creating a multi-purpose agent that handles different industries

from typing import Dict, List
import json

class IndustryAgentRouter:
    """
    Routes queries to appropriate industry-specific agents
    Based on patterns from the 500 AI Agents catalog
    """
    
    def __init__(self):
        self.industry_keywords = {
            'healthcare': ['medical', 'health', 'diagnosis', 'patient', 'treatment'],
            'finance': ['trading', 'stock', 'investment', 'market', 'portfolio'],
            'education': ['learn', 'study', 'course', 'tutor', 'exam'],
            'retail': ['product', 'shop', 'purchase', 'recommendation', 'inventory'],
            'customer_service': ['support', 'help', 'ticket', 'complaint', 'query']
        }
        self.agents = self._initialize_agents()
    
    def _initialize_agents(self) -> Dict:
        """Initialize industry-specific agents"""
        return {
            'healthcare': HealthcareAgent(),
            'finance': FinanceAgent(),
            'education': EducationAgent(),
            'retail': RetailAgent(),
            'customer_service': CustomerServiceAgent()
        }
    
    def classify_query(self, query: str) -> str:
        """Classify query to determine industry"""
        query_lower = query.lower()
        scores = {}
        
        for industry, keywords in self.industry_keywords.items():
            score = sum(1 for keyword in keywords if keyword in query_lower)
            scores[industry] = score
        
        return max(scores, key=scores.get) if max(scores.values()) > 0 else 'general'
    
    def route_query(self, query: str) -> str:
        """Route query to appropriate agent"""
        industry = self.classify_query(query)
        
        if industry in self.agents:
            return self.agents[industry].process(query)
        else:
            return "I'm not sure which department can help with that. Can you be more specific?"

# Usage
router = IndustryAgentRouter()
response = router.route_query("I need help analyzing my stock portfolio")

Environment Variables

When implementing agents from the catalog, common environment variables needed:

# LLM API Keys
export OPENAI_API_KEY=your_openai_key
export ANTHROPIC_API_KEY=your_anthropic_key
export GOOGLE_API_KEY=your_google_key

# Framework-specific
export CREWAI_API_KEY=your_crewai_key
export LANGCHAIN_API_KEY=your_langchain_key

# Database (if needed)
export DATABASE_URL=your_database_url

# Vector stores
export PINECONE_API_KEY=your_pinecone_key
export WEAVIATE_URL=your_weaviate_url

Troubleshooting

Issue: Repository Links Not Working

Some projects may have been moved or archived. Check the original repository:

import requests

def verify_github_link(github_url: str) -> bool:
    """Verify if GitHub repository still exists"""
    response = requests.get(github_url)
    return response.status_code == 200

# Usage
url = "https://github.com/harshhh28/hia"
if verify_github_link(url):
    print("Repository is accessible")
else:
    print("Repository may have moved or been deleted")

Issue: Framework Version Compatibility

Different examples may use different framework versions:

# Check requirements from a specific example
curl -s https://raw.githubusercontent.com/crewAIInc/crewAI-examples/main/requirements.txt

# Install specific version
pip install crewai==0.1.0  # Use version from example

Issue: Finding Similar Use Cases

If you can't find an exact match, search for similar patterns:

from difflib import SequenceMatcher

def find_similar_use_cases(target_description: str, all_use_cases: List[Dict], threshold=0.6):
    """Find use cases similar to target description"""
    similar = []
    
    for use_case in all_use_cases:
        similarity = SequenceMatcher(
            None,
            target_description.lower(),
            use_case['description'].lower()
        ).ratio()
        
        if similarity >= threshold:
            similar.append({
                'use_case': use_case,
                'similarity': similarity
            })
    
    return sorted(similar, key=lambda x: x['similarity'], reverse=True)

Best Practices

1. Start with Framework Examples: Begin with the framework-specific section (CrewAI, AutoGen, LangGraph) to understand implementation patterns

2. Check Repository Activity: Before implementing, verify the GitHub repository is actively maintained

3. Adapt to Your Needs: Use catalog examples as starting points, not complete solutions

4. Combine Use Cases: Many real-world applications combine multiple agent types (e.g., customer service + recommendation)

5. Environment Configuration: Always use environment variables for API keys and sensitive configuration

6. Version Control: Pin framework versions to match the examples for reproducibility

Additional Resources

• Main Repository: https://github.com/ashishpatel26/500-AI-Agents-Projects
• CrewAI Examples: https://github.com/crewAIInc/crewAI-examples
• AutoGen Documentation: https://microsoft.github.io/autogen/
• LangGraph Documentation: https://langchain-ai.github.io/langgraph/