+ Get personalized dietary and fitness plans tailored to your goals and preferences.
+ Our AI-powered system considers your unique profile to create the perfect plan for you.
+
+ """, unsafe_allow_html=True)
+
+ with st.sidebar:
+ st.header("๐ API Configuration")
+ gemini_api_key = st.text_input(
+ "Gemini API Key",
+ type="password",
+ help="Enter your Gemini API key to access the service"
+ )
+
+ if not gemini_api_key:
+ st.warning("โ ๏ธ Please enter your Gemini API Key to proceed")
+ st.markdown("[Get your API key here](https://aistudio.google.com/apikey)")
+ return
+
+ st.success("API Key accepted!")
+
+ if gemini_api_key:
+ try:
+ gemini_model = Gemini(id="gemini-1.5-flash", api_key=gemini_api_key)
+ except Exception as e:
+ st.error(f"โ Error initializing Gemini model: {e}")
+ return
+
+ st.header("๐ค Your Profile")
+
+ col1, col2 = st.columns(2)
+
+ with col1:
+ age = st.number_input("Age", min_value=10, max_value=100, step=1, help="Enter your age")
+ height = st.number_input("Height (cm)", min_value=100.0, max_value=250.0, step=0.1)
+ activity_level = st.selectbox(
+ "Activity Level",
+ options=["Sedentary", "Lightly Active", "Moderately Active", "Very Active", "Extremely Active"],
+ help="Choose your typical activity level"
+ )
+ dietary_preferences = st.selectbox(
+ "Dietary Preferences",
+ options=["Vegetarian", "Keto", "Gluten Free", "Low Carb", "Dairy Free"],
+ help="Select your dietary preference"
+ )
+
+ with col2:
+ weight = st.number_input("Weight (kg)", min_value=20.0, max_value=300.0, step=0.1)
+ sex = st.selectbox("Sex", options=["Male", "Female", "Other"])
+ fitness_goals = st.selectbox(
+ "Fitness Goals",
+ options=["Lose Weight", "Gain Muscle", "Endurance", "Stay Fit", "Strength Training"],
+ help="What do you want to achieve?"
+ )
+
+ if st.button("๐ฏ Generate My Personalized Plan", use_container_width=True):
+ with st.spinner("Creating your perfect health and fitness routine..."):
+ try:
+ dietary_agent = Agent(
+ name="Dietary Expert",
+ role="Provides personalized dietary recommendations",
+ model=gemini_model,
+ instructions=[
+ "Consider the user's input, including dietary restrictions and preferences.",
+ "Suggest a detailed meal plan for the day, including breakfast, lunch, dinner, and snacks.",
+ "Provide a brief explanation of why the plan is suited to the user's goals.",
+ "Focus on clarity, coherence, and quality of the recommendations.",
+ ]
+ )
+
+ fitness_agent = Agent(
+ name="Fitness Expert",
+ role="Provides personalized fitness recommendations",
+ model=gemini_model,
+ instructions=[
+ "Provide exercises tailored to the user's goals.",
+ "Include warm-up, main workout, and cool-down exercises.",
+ "Explain the benefits of each recommended exercise.",
+ "Ensure the plan is actionable and detailed.",
+ ]
+ )
+
+ user_profile = f"""
+ Age: {age}
+ Weight: {weight}kg
+ Height: {height}cm
+ Sex: {sex}
+ Activity Level: {activity_level}
+ Dietary Preferences: {dietary_preferences}
+ Fitness Goals: {fitness_goals}
+ """
+
+ dietary_plan_response = dietary_agent.run(user_profile)
+ dietary_plan = {
+ "why_this_plan_works": "High Protein, Healthy Fats, Moderate Carbohydrates, and Caloric Balance",
+ "meal_plan": dietary_plan_response.content,
+ "important_considerations": """
+ - Hydration: Drink plenty of water throughout the day
+ - Electrolytes: Monitor sodium, potassium, and magnesium levels
+ - Fiber: Ensure adequate intake through vegetables and fruits
+ - Listen to your body: Adjust portion sizes as needed
+ """
+ }
+
+ fitness_plan_response = fitness_agent.run(user_profile)
+ fitness_plan = {
+ "goals": "Build strength, improve endurance, and maintain overall fitness",
+ "routine": fitness_plan_response.content,
+ "tips": """
+ - Track your progress regularly
+ - Allow proper rest between workouts
+ - Focus on proper form
+ - Stay consistent with your routine
+ """
+ }
+
+ st.session_state.dietary_plan = dietary_plan
+ st.session_state.fitness_plan = fitness_plan
+ st.session_state.plans_generated = True
+ st.session_state.qa_pairs = []
+
+ display_dietary_plan(dietary_plan)
+ display_fitness_plan(fitness_plan)
+
+ except Exception as e:
+ st.error(f"โ An error occurred: {e}")
+
+ if st.session_state.plans_generated:
+ st.header("โ Questions about your plan?")
+ question_input = st.text_input("What would you like to know?")
+
+ if st.button("Get Answer"):
+ if question_input:
+ with st.spinner("Finding the best answer for you..."):
+ dietary_plan = st.session_state.dietary_plan
+ fitness_plan = st.session_state.fitness_plan
+
+ context = f"Dietary Plan: {dietary_plan.get('meal_plan', '')}\n\nFitness Plan: {fitness_plan.get('routine', '')}"
+ full_context = f"{context}\nUser Question: {question_input}"
+
+ try:
+ agent = Agent(model=gemini_model, show_tool_calls=True, markdown=True)
+ run_response = agent.run(full_context)
+
+ if hasattr(run_response, 'content'):
+ answer = run_response.content
+ else:
+ answer = "Sorry, I couldn't generate a response at this time."
+
+ st.session_state.qa_pairs.append((question_input, answer))
+ except Exception as e:
+ st.error(f"โ An error occurred while getting the answer: {e}")
+
+ if st.session_state.qa_pairs:
+ st.header("๐ฌ Q&A History")
+ for question, answer in st.session_state.qa_pairs:
+ st.markdown(f"**Q:** {question}")
+ st.markdown(f"**A:** {answer}")
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_health_fitness_agent/requirements.txt b/ai_agent_tutorials/ai_health_fitness_agent/requirements.txt
new file mode 100644
index 0000000..0762e21
--- /dev/null
+++ b/ai_agent_tutorials/ai_health_fitness_agent/requirements.txt
@@ -0,0 +1,3 @@
+google-generativeai==0.8.3
+streamlit==1.40.2
+agno
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_investment_agent/README.md b/ai_agent_tutorials/ai_investment_agent/README.md
index f655d04..6ce5973 100644
--- a/ai_agent_tutorials/ai_investment_agent/README.md
+++ b/ai_agent_tutorials/ai_investment_agent/README.md
@@ -1,5 +1,5 @@
## ๐ AI Investment Agent
-This Streamlit app is an AI-powered investment agent that compares the performance of two stocks and generates detailed reports. By using GPT-4o with Yahoo Finance data, this app provides valuable insights to help you make informed investment decisions.
+This Streamlit app is an AI-powered investment agent built with Agno's AI Agent framework that compares the performance of two stocks and generates detailed reports. By using GPT-4o with Yahoo Finance data, this app provides valuable insights to help you make informed investment decisions.
### Features
- Compare the performance of two stocks
@@ -13,6 +13,7 @@ This Streamlit app is an AI-powered investment agent that compares the performan
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_investment_agent
```
2. Install the required dependencies:
@@ -31,7 +32,7 @@ streamlit run investment_agent.py
### How it Works?
- Upon running the app, you will be prompted to enter your OpenAI API key. This key is used to authenticate and access the OpenAI language model.
-- Once you provide a valid API key, an instance of the Assistant class is created. This assistant utilizes the GPT-4 language model from OpenAI and the YFinanceTools for accessing stock data.
+- Once you provide a valid API key, an instance of the Assistant class is created. This assistant utilizes the GPT-4o language model from OpenAI and the YFinanceTools for accessing stock data.
- Enter the stock symbols of the two companies you want to compare in the provided text input fields.
- The assistant will perform the following steps:
- Retrieve real-time stock prices and historical data using YFinanceTools
diff --git a/ai_agent_tutorials/ai_investment_agent/investment_agent.py b/ai_agent_tutorials/ai_investment_agent/investment_agent.py
index 2bd474d..699c2cc 100644
--- a/ai_agent_tutorials/ai_investment_agent/investment_agent.py
+++ b/ai_agent_tutorials/ai_investment_agent/investment_agent.py
@@ -1,30 +1,34 @@
-# Import the required libraries
import streamlit as st
-from phi.assistant import Assistant
-from phi.llm.openai import OpenAIChat
-from phi.tools.yfinance import YFinanceTools
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+from agno.tools.yfinance import YFinanceTools
-# Set up the Streamlit app
st.title("AI Investment Agent ๐๐ค")
st.caption("This app allows you to compare the performance of two stocks and generate detailed reports.")
-# Get OpenAI API key from user
openai_api_key = st.text_input("OpenAI API Key", type="password")
if openai_api_key:
- # Create an instance of the Assistant
- assistant = Assistant(
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
- tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
+ assistant = Agent(
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
+ tools=[
+ YFinanceTools(stock_price=True, analyst_recommendations=True, stock_fundamentals=True)
+ ],
show_tool_calls=True,
+ description="You are an investment analyst that researches stock prices, analyst recommendations, and stock fundamentals.",
+ instructions=[
+ "Format your response using markdown and use tables to display data where possible."
+ ],
)
- # Input fields for the stocks to compare
- stock1 = st.text_input("Enter the first stock symbol")
- stock2 = st.text_input("Enter the second stock symbol")
+ col1, col2 = st.columns(2)
+ with col1:
+ stock1 = st.text_input("Enter first stock symbol (e.g. AAPL)")
+ with col2:
+ stock2 = st.text_input("Enter second stock symbol (e.g. MSFT)")
if stock1 and stock2:
- # Get the response from the assistant
- query = f"Compare {stock1} to {stock2}. Use every tool you have."
- response = assistant.run(query, stream=False)
- st.write(response)
\ No newline at end of file
+ with st.spinner(f"Analyzing {stock1} and {stock2}..."):
+ query = f"Compare both the stocks - {stock1} and {stock2} and make a detailed report for an investment trying to invest and compare these stocks"
+ response = assistant.run(query, stream=False)
+ st.markdown(response.content)
diff --git a/ai_agent_tutorials/ai_investment_agent/requirements.txt b/ai_agent_tutorials/ai_investment_agent/requirements.txt
index fe27582..b25ad27 100644
--- a/ai_agent_tutorials/ai_investment_agent/requirements.txt
+++ b/ai_agent_tutorials/ai_investment_agent/requirements.txt
@@ -1,4 +1,4 @@
streamlit
-phidata
+agno
openai
yfinance
diff --git a/ai_agent_tutorials/ai_journalist_agent/README.md b/ai_agent_tutorials/ai_journalist_agent/README.md
index 76b3df7..18aa2ae 100644
--- a/ai_agent_tutorials/ai_journalist_agent/README.md
+++ b/ai_agent_tutorials/ai_journalist_agent/README.md
@@ -12,6 +12,7 @@ This Streamlit app is an AI-powered journalist agent that generates high-quality
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_journalist_agent
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/ai_journalist_agent/journalist_agent.py b/ai_agent_tutorials/ai_journalist_agent/journalist_agent.py
index 48bde3b..af7390b 100644
--- a/ai_agent_tutorials/ai_journalist_agent/journalist_agent.py
+++ b/ai_agent_tutorials/ai_journalist_agent/journalist_agent.py
@@ -1,10 +1,10 @@
# Import the required libraries
from textwrap import dedent
-from phi.assistant import Assistant
-from phi.tools.serpapi_tools import SerpApiTools
-from phi.tools.newspaper_toolkit import NewspaperToolkit
+from agno.agent import Agent
+from agno.tools.serpapi import SerpApiTools
+from agno.tools.newspaper4k import Newspaper4kTools
import streamlit as st
-from phi.llm.openai import OpenAIChat
+from agno.models.openai import OpenAIChat
# Set up the Streamlit app
st.title("AI Journalist Agent ๐๏ธ")
@@ -17,10 +17,10 @@ openai_api_key = st.text_input("Enter OpenAI API Key to access GPT-4o", type="pa
serp_api_key = st.text_input("Enter Serp API Key for Search functionality", type="password")
if openai_api_key and serp_api_key:
- searcher = Assistant(
+ searcher = Agent(
name="Searcher",
role="Searches for top URLs based on a topic",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a world-class journalist for the New York Times. Given a topic, generate a list of 3 search terms
@@ -37,10 +37,10 @@ if openai_api_key and serp_api_key:
tools=[SerpApiTools(api_key=serp_api_key)],
add_datetime_to_instructions=True,
)
- writer = Assistant(
+ writer = Agent(
name="Writer",
role="Retrieves text from URLs and writes a high-quality article",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a senior writer for the New York Times. Given a topic and a list of URLs,
@@ -57,15 +57,14 @@ if openai_api_key and serp_api_key:
"Focus on clarity, coherence, and overall quality.",
"Never make up facts or plagiarize. Always provide proper attribution.",
],
- tools=[NewspaperToolkit()],
+ tools=[Newspaper4kTools()],
add_datetime_to_instructions=True,
- add_chat_history_to_prompt=True,
- num_history_messages=3,
+ markdown=True,
)
- editor = Assistant(
+ editor = Agent(
name="Editor",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
team=[searcher, writer],
description="You are a senior NYT editor. Given a topic, your goal is to write a NYT worthy article.",
instructions=[
@@ -88,4 +87,4 @@ if openai_api_key and serp_api_key:
with st.spinner("Processing..."):
# Get the response from the assistant
response = editor.run(query, stream=False)
- st.write(response)
\ No newline at end of file
+ st.write(response.content)
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_journalist_agent/requirements.txt b/ai_agent_tutorials/ai_journalist_agent/requirements.txt
index 2316761..c97808a 100644
--- a/ai_agent_tutorials/ai_journalist_agent/requirements.txt
+++ b/ai_agent_tutorials/ai_journalist_agent/requirements.txt
@@ -1,6 +1,6 @@
streamlit
-phidata
+agno
openai
google-search-results
-newspaper3k
+newspaper4k
lxml_html_clean
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_lead_generation_agent/README.md b/ai_agent_tutorials/ai_lead_generation_agent/README.md
new file mode 100644
index 0000000..93da1f7
--- /dev/null
+++ b/ai_agent_tutorials/ai_lead_generation_agent/README.md
@@ -0,0 +1,35 @@
+## ๐ฏ AI Lead Generation Agent - Powered by Firecrawl's Extract Endpoint
+
+The AI Lead Generation Agent automates the process of finding and qualifying potential leads from Quora. It uses Firecrawl's search and the new Extract endpoint to identify relevant user profiles, extract valuable information, and organize it into a structured format in Google Sheets. This agent helps sales and marketing teams efficiently build targeted lead lists while saving hours of manual research.
+
+### Features
+- **Targeted Search**: Uses Firecrawl's search endpoint to find relevant Quora URLs based on your search criteria
+- **Intelligent Extraction**: Leverages Firecrawl's new Extract endpoint to pull user information from Quora profiles
+- **Automated Processing**: Formats extracted user information into a clean, structured format
+- **Google Sheets Integration**: Automatically creates and populates Google Sheets with lead information
+- **Customizable Criteria**: Allows you to define specific search parameters to find your ideal leads for your niche
+
+### How to Get Started
+1. **Clone the repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_lead_generation_agent
+ ```
+3. **Install the required packages**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+4. **Important thing to do in composio**:
+ - in the terminal, run this command: `composio add googlesheets`
+ - In your compposio dashboard, create a new google sheet intergation and make sure it is active in the active integrations/connections tab
+
+5. **Set up your API keys**:
+ - Get your Firecrawl API key from [Firecrawl's website](https://www.firecrawl.dev/app/api-keys)
+ - Get your Composio API key from [Composio's website](https://composio.ai)
+ - Get your OpenAI API key from [OpenAI's website](https://platform.openai.com/api-keys)
+
+6. **Run the application**:
+ ```bash
+ streamlit run ai_lead_generation_agent.py
+ ```
+
diff --git a/ai_agent_tutorials/ai_lead_generation_agent/ai_lead_generation_agent.py b/ai_agent_tutorials/ai_lead_generation_agent/ai_lead_generation_agent.py
new file mode 100644
index 0000000..2814167
--- /dev/null
+++ b/ai_agent_tutorials/ai_lead_generation_agent/ai_lead_generation_agent.py
@@ -0,0 +1,209 @@
+import streamlit as st
+import requests
+from agno.agent import Agent
+from agno.tools.firecrawl import FirecrawlTools
+from agno.models.openai import OpenAIChat
+from firecrawl import FirecrawlApp
+from pydantic import BaseModel, Field
+from typing import List
+from composio_phidata import Action, ComposioToolSet
+import json
+
+class QuoraUserInteractionSchema(BaseModel):
+ username: str = Field(description="The username of the user who posted the question or answer")
+ bio: str = Field(description="The bio or description of the user")
+ post_type: str = Field(description="The type of post, either 'question' or 'answer'")
+ timestamp: str = Field(description="When the question or answer was posted")
+ upvotes: int = Field(default=0, description="Number of upvotes received")
+ links: List[str] = Field(default_factory=list, description="Any links included in the post")
+
+class QuoraPageSchema(BaseModel):
+ interactions: List[QuoraUserInteractionSchema] = Field(description="List of all user interactions (questions and answers) on the page")
+
+def search_for_urls(company_description: str, firecrawl_api_key: str, num_links: int) -> List[str]:
+ url = "https://api.firecrawl.dev/v1/search"
+ headers = {
+ "Authorization": f"Bearer {firecrawl_api_key}",
+ "Content-Type": "application/json"
+ }
+ query1 = f"quora websites where people are looking for {company_description} services"
+ payload = {
+ "query": query1,
+ "limit": num_links,
+ "lang": "en",
+ "location": "United States",
+ "timeout": 60000,
+ }
+ response = requests.post(url, json=payload, headers=headers)
+ if response.status_code == 200:
+ data = response.json()
+ if data.get("success"):
+ results = data.get("data", [])
+ return [result["url"] for result in results]
+ return []
+
+def extract_user_info_from_urls(urls: List[str], firecrawl_api_key: str) -> List[dict]:
+ user_info_list = []
+ firecrawl_app = FirecrawlApp(api_key=firecrawl_api_key)
+
+ try:
+ for url in urls:
+ response = firecrawl_app.extract(
+ [url],
+ {
+ 'prompt': 'Extract all user information including username, bio, post type (question/answer), timestamp, upvotes, and any links from Quora posts. Focus on identifying potential leads who are asking questions or providing answers related to the topic.',
+ 'schema': QuoraPageSchema.model_json_schema(),
+ }
+ )
+
+ if response.get('success') and response.get('status') == 'completed':
+ interactions = response.get('data', {}).get('interactions', [])
+ if interactions:
+ user_info_list.append({
+ "website_url": url,
+ "user_info": interactions
+ })
+ except Exception:
+ pass
+
+ return user_info_list
+
+def format_user_info_to_flattened_json(user_info_list: List[dict]) -> List[dict]:
+ flattened_data = []
+
+ for info in user_info_list:
+ website_url = info["website_url"]
+ user_info = info["user_info"]
+
+ for interaction in user_info:
+ flattened_interaction = {
+ "Website URL": website_url,
+ "Username": interaction.get("username", ""),
+ "Bio": interaction.get("bio", ""),
+ "Post Type": interaction.get("post_type", ""),
+ "Timestamp": interaction.get("timestamp", ""),
+ "Upvotes": interaction.get("upvotes", 0),
+ "Links": ", ".join(interaction.get("links", [])),
+ }
+ flattened_data.append(flattened_interaction)
+
+ return flattened_data
+
+def create_google_sheets_agent(composio_api_key: str, openai_api_key: str) -> Agent:
+ composio_toolset = ComposioToolSet(api_key=composio_api_key)
+ google_sheets_tool = composio_toolset.get_tools(actions=[Action.GOOGLESHEETS_SHEET_FROM_JSON])[0]
+
+ google_sheets_agent = Agent(
+ model=OpenAIChat(id="gpt-4o-mini", api_key=openai_api_key),
+ tools=[google_sheets_tool],
+ show_tool_calls=True,
+ system_prompt="You are an expert at creating and updating Google Sheets. You will be given user information in JSON format, and you need to write it into a new Google Sheet.",
+ markdown=True
+ )
+ return google_sheets_agent
+
+def write_to_google_sheets(flattened_data: List[dict], composio_api_key: str, openai_api_key: str) -> str:
+ google_sheets_agent = create_google_sheets_agent(composio_api_key, openai_api_key)
+
+ try:
+ message = (
+ "Create a new Google Sheet with this data. "
+ "The sheet should have these columns: Website URL, Username, Bio, Post Type, Timestamp, Upvotes, and Links in the same order as mentioned. "
+ "Here's the data in JSON format:\n\n"
+ f"{json.dumps(flattened_data, indent=2)}"
+ )
+
+ create_sheet_response = google_sheets_agent.run(message)
+
+ if "https://docs.google.com/spreadsheets/d/" in create_sheet_response.content:
+ google_sheets_link = create_sheet_response.content.split("https://docs.google.com/spreadsheets/d/")[1].split(" ")[0]
+ return f"https://docs.google.com/spreadsheets/d/{google_sheets_link}"
+ except Exception:
+ pass
+ return None
+
+def create_prompt_transformation_agent(openai_api_key: str) -> Agent:
+ return Agent(
+ model=OpenAIChat(id="gpt-4o-mini", api_key=openai_api_key),
+ system_prompt="""You are an expert at transforming detailed user queries into concise company descriptions.
+Your task is to extract the core business/product focus in 3-4 words.
+
+Examples:
+Input: "Generate leads looking for AI-powered customer support chatbots for e-commerce stores."
+Output: "AI customer support chatbots for e commerce"
+
+Input: "Find people interested in voice cloning technology for creating audiobooks and podcasts"
+Output: "voice cloning technology"
+
+Input: "Looking for users who need automated video editing software with AI capabilities"
+Output: "AI video editing software"
+
+Input: "Need to find businesses interested in implementing machine learning solutions for fraud detection"
+Output: "ML fraud detection"
+
+Always focus on the core product/service and keep it concise but clear.""",
+ markdown=True
+ )
+
+def main():
+ st.title("๐ฏ AI Lead Generation Agent")
+ st.info("This firecrawl powered agent helps you generate leads from Quora by searching for relevant posts and extracting user information.")
+
+ with st.sidebar:
+ st.header("API Keys")
+ firecrawl_api_key = st.text_input("Firecrawl API Key", type="password")
+ st.caption(" Get your Firecrawl API key from [Firecrawl's website](https://www.firecrawl.dev/app/api-keys)")
+ openai_api_key = st.text_input("OpenAI API Key", type="password")
+ st.caption(" Get your OpenAI API key from [OpenAI's website](https://platform.openai.com/api-keys)")
+ composio_api_key = st.text_input("Composio API Key", type="password")
+ st.caption(" Get your Composio API key from [Composio's website](https://composio.ai)")
+
+ num_links = st.number_input("Number of links to search", min_value=1, max_value=10, value=3)
+
+ if st.button("Reset"):
+ st.session_state.clear()
+ st.experimental_rerun()
+
+ user_query = st.text_area(
+ "Describe what kind of leads you're looking for:",
+ placeholder="e.g., Looking for users who need automated video editing software with AI capabilities",
+ help="Be specific about the product/service and target audience. The AI will convert this into a focused search query."
+ )
+
+ if st.button("Generate Leads"):
+ if not all([firecrawl_api_key, openai_api_key, composio_api_key, user_query]):
+ st.error("Please fill in all the API keys and describe what leads you're looking for.")
+ else:
+ with st.spinner("Processing your query..."):
+ transform_agent = create_prompt_transformation_agent(openai_api_key)
+ company_description = transform_agent.run(f"Transform this query into a concise 3-4 word company description: {user_query}")
+ st.write("๐ฏ Searching for:", company_description.content)
+
+ with st.spinner("Searching for relevant URLs..."):
+ urls = search_for_urls(company_description.content, firecrawl_api_key, num_links)
+
+ if urls:
+ st.subheader("Quora Links Used:")
+ for url in urls:
+ st.write(url)
+
+ with st.spinner("Extracting user info from URLs..."):
+ user_info_list = extract_user_info_from_urls(urls, firecrawl_api_key)
+
+ with st.spinner("Formatting user info..."):
+ flattened_data = format_user_info_to_flattened_json(user_info_list)
+
+ with st.spinner("Writing to Google Sheets..."):
+ google_sheets_link = write_to_google_sheets(flattened_data, composio_api_key, openai_api_key)
+
+ if google_sheets_link:
+ st.success("Lead generation and data writing to Google Sheets completed successfully!")
+ st.subheader("Google Sheets Link:")
+ st.markdown(f"[View Google Sheet]({google_sheets_link})")
+ else:
+ st.error("Failed to retrieve the Google Sheets link.")
+ else:
+ st.warning("No relevant URLs found.")
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_lead_generation_agent/requirements.txt b/ai_agent_tutorials/ai_lead_generation_agent/requirements.txt
new file mode 100644
index 0000000..5fa3753
--- /dev/null
+++ b/ai_agent_tutorials/ai_lead_generation_agent/requirements.txt
@@ -0,0 +1,6 @@
+firecrawl-py==1.9.0
+agno
+composio-phidata
+composio==0.1.1
+pydantic==2.10.5
+streamlit
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_legal_agent_team/README.md b/ai_agent_tutorials/ai_legal_agent_team/README.md
new file mode 100644
index 0000000..d97cd99
--- /dev/null
+++ b/ai_agent_tutorials/ai_legal_agent_team/README.md
@@ -0,0 +1,56 @@
+# ๐จโโ๏ธ AI Legal Agent Team
+
+A Streamlit application that simulates a full-service legal team using multiple AI agents to analyze legal documents and provide comprehensive legal insights. Each agent represents a different legal specialist role, from research and contract analysis to strategic planning, working together to provide thorough legal analysis and recommendations.
+
+## Features
+
+- **Specialized Legal AI Agent Team**
+ - **Legal Researcher**: Equipped with DuckDuckGo search tool to find and cite relevant legal cases and precedents. Provides detailed research summaries with sources and references specific sections from uploaded documents.
+
+ - **Contract Analyst**: Specializes in thorough contract review, identifying key terms, obligations, and potential issues. References specific clauses from documents for detailed analysis.
+
+ - **Legal Strategist**: Focuses on developing comprehensive legal strategies, providing actionable recommendations while considering both risks and opportunities.
+
+ - **Team Lead**: Coordinates analysis between team members, ensures comprehensive responses, properly sourced recommendations, and references to specific document parts. Acts as an Agent Team coordinator for all three agents.
+
+- **Document Analysis Types**
+ - Contract Review - Done by Contract Analyst
+ - Legal Research - Done by Legal Researcher
+ - Risk Assessment - Done by Legal Strategist, Contract Analyst
+ - Compliance Check - Done by Legal Strategist, Legal Researcher, Contract Analyst
+ - Custom Queries - Done by Agent Team - Legal Researcher, Legal Strategist, Contract Analyst
+
+## How to Run
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd awesome-llm-apps/ai_agent_tutorials/ai_legal_agent_team
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+2. **Configure API Keys**
+ - Get OpenAI API key from [OpenAI Platform](https://platform.openai.com)
+ - Get Qdrant API key and URL from [Qdrant Cloud](https://cloud.qdrant.io)
+
+3. **Run the Application**
+ ```bash
+ streamlit run legal_agent_team.py
+ ```
+4. **Use the Interface**
+ - Enter API credentials
+ - Upload a legal document (PDF)
+ - Select analysis type
+ - Add custom queries if needed
+ - View analysis results
+
+## Notes
+
+- Supports PDF documents only
+- Uses GPT-4o for analysis
+- Uses text-embedding-3-small for embeddings
+- Requires stable internet connection
+- API usage costs apply
diff --git a/ai_agent_tutorials/ai_legal_agent_team/legal_agent_team.py b/ai_agent_tutorials/ai_legal_agent_team/legal_agent_team.py
new file mode 100644
index 0000000..46a705b
--- /dev/null
+++ b/ai_agent_tutorials/ai_legal_agent_team/legal_agent_team.py
@@ -0,0 +1,400 @@
+import streamlit as st
+from agno.agent import Agent
+from agno.knowledge.pdf import PDFKnowledgeBase, PDFReader
+from agno.vectordb.qdrant import Qdrant
+from agno.tools.duckduckgo import DuckDuckGoTools
+from agno.models.openai import OpenAIChat
+from agno.embedder.openai import OpenAIEmbedder
+import tempfile
+import os
+from agno.document.chunking.document import DocumentChunking
+
+def init_session_state():
+ """Initialize session state variables"""
+ if 'openai_api_key' not in st.session_state:
+ st.session_state.openai_api_key = None
+ if 'qdrant_api_key' not in st.session_state:
+ st.session_state.qdrant_api_key = None
+ if 'qdrant_url' not in st.session_state:
+ st.session_state.qdrant_url = None
+ if 'vector_db' not in st.session_state:
+ st.session_state.vector_db = None
+ if 'legal_team' not in st.session_state:
+ st.session_state.legal_team = None
+ if 'knowledge_base' not in st.session_state:
+ st.session_state.knowledge_base = None
+ # Add a new state variable to track processed files
+ if 'processed_files' not in st.session_state:
+ st.session_state.processed_files = set()
+
+COLLECTION_NAME = "legal_documents" # Define your collection name
+
+def init_qdrant():
+ """Initialize Qdrant client with configured settings."""
+ if not all([st.session_state.qdrant_api_key, st.session_state.qdrant_url]):
+ return None
+ try:
+ # Create Agno's Qdrant instance which implements VectorDb
+ vector_db = Qdrant(
+ collection=COLLECTION_NAME,
+ url=st.session_state.qdrant_url,
+ api_key=st.session_state.qdrant_api_key,
+ embedder=OpenAIEmbedder(
+ id="text-embedding-3-small",
+ api_key=st.session_state.openai_api_key
+ )
+ )
+ return vector_db
+ except Exception as e:
+ st.error(f"๐ด Qdrant connection failed: {str(e)}")
+ return None
+
+def process_document(uploaded_file, vector_db: Qdrant):
+ """
+ Process document, create embeddings and store in Qdrant vector database
+
+ Args:
+ uploaded_file: Streamlit uploaded file object
+ vector_db (Qdrant): Initialized Qdrant instance from Agno
+
+ Returns:
+ PDFKnowledgeBase: Initialized knowledge base with processed documents
+ """
+ if not st.session_state.openai_api_key:
+ raise ValueError("OpenAI API key not provided")
+
+ os.environ['OPENAI_API_KEY'] = st.session_state.openai_api_key
+
+ try:
+ # Save the uploaded file to a temporary location
+ with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
+ temp_file.write(uploaded_file.getvalue())
+ temp_file_path = temp_file.name
+
+ st.info("Loading and processing document...")
+
+ # Create a PDFKnowledgeBase with the vector_db
+ knowledge_base = PDFKnowledgeBase(
+ path=temp_file_path, # Single string path, not a list
+ vector_db=vector_db,
+ reader=PDFReader(),
+ chunking_strategy=DocumentChunking(
+ chunk_size=1000,
+ overlap=200
+ )
+ )
+
+ # Load the documents into the knowledge base
+ with st.spinner('๐ค Loading documents into knowledge base...'):
+ try:
+ knowledge_base.load(recreate=True, upsert=True)
+ st.success("โ
Documents stored successfully!")
+ except Exception as e:
+ st.error(f"Error loading documents: {str(e)}")
+ raise
+
+ # Clean up the temporary file
+ try:
+ os.unlink(temp_file_path)
+ except Exception:
+ pass
+
+ return knowledge_base
+
+ except Exception as e:
+ st.error(f"Document processing error: {str(e)}")
+ raise Exception(f"Error processing document: {str(e)}")
+
+def main():
+ st.set_page_config(page_title="Legal Document Analyzer", layout="wide")
+ init_session_state()
+
+ st.title("AI Legal Agent Team ๐จโโ๏ธ")
+
+ with st.sidebar:
+ st.header("๐ API Configuration")
+
+ openai_key = st.text_input(
+ "OpenAI API Key",
+ type="password",
+ value=st.session_state.openai_api_key if st.session_state.openai_api_key else "",
+ help="Enter your OpenAI API key"
+ )
+ if openai_key:
+ st.session_state.openai_api_key = openai_key
+
+ qdrant_key = st.text_input(
+ "Qdrant API Key",
+ type="password",
+ value=st.session_state.qdrant_api_key if st.session_state.qdrant_api_key else "",
+ help="Enter your Qdrant API key"
+ )
+ if qdrant_key:
+ st.session_state.qdrant_api_key = qdrant_key
+
+ qdrant_url = st.text_input(
+ "Qdrant URL",
+ value=st.session_state.qdrant_url if st.session_state.qdrant_url else "",
+ help="Enter your Qdrant instance URL"
+ )
+ if qdrant_url:
+ st.session_state.qdrant_url = qdrant_url
+
+ if all([st.session_state.qdrant_api_key, st.session_state.qdrant_url]):
+ try:
+ if not st.session_state.vector_db:
+ # Make sure we're initializing a QdrantClient here
+ st.session_state.vector_db = init_qdrant()
+ if st.session_state.vector_db:
+ st.success("Successfully connected to Qdrant!")
+ except Exception as e:
+ st.error(f"Failed to connect to Qdrant: {str(e)}")
+
+ st.divider()
+
+ if all([st.session_state.openai_api_key, st.session_state.vector_db]):
+ st.header("๐ Document Upload")
+ uploaded_file = st.file_uploader("Upload Legal Document", type=['pdf'])
+
+ if uploaded_file:
+ # Check if this file has already been processed
+ if uploaded_file.name not in st.session_state.processed_files:
+ with st.spinner("Processing document..."):
+ try:
+ # Process the document and get the knowledge base
+ knowledge_base = process_document(uploaded_file, st.session_state.vector_db)
+
+ if knowledge_base:
+ st.session_state.knowledge_base = knowledge_base
+ # Add the file to processed files
+ st.session_state.processed_files.add(uploaded_file.name)
+
+ # Initialize agents
+ legal_researcher = Agent(
+ name="Legal Researcher",
+ role="Legal research specialist",
+ model=OpenAIChat(id="gpt-4o"),
+ tools=[DuckDuckGoTools()],
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Find and cite relevant legal cases and precedents",
+ "Provide detailed research summaries with sources",
+ "Reference specific sections from the uploaded document",
+ "Always search the knowledge base for relevant information"
+ ],
+ show_tool_calls=True,
+ markdown=True
+ )
+
+ contract_analyst = Agent(
+ name="Contract Analyst",
+ role="Contract analysis specialist",
+ model=OpenAIChat(id="gpt-4o"),
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Review contracts thoroughly",
+ "Identify key terms and potential issues",
+ "Reference specific clauses from the document"
+ ],
+ markdown=True
+ )
+
+ legal_strategist = Agent(
+ name="Legal Strategist",
+ role="Legal strategy specialist",
+ model=OpenAIChat(id="gpt-4o"),
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Develop comprehensive legal strategies",
+ "Provide actionable recommendations",
+ "Consider both risks and opportunities"
+ ],
+ markdown=True
+ )
+
+ # Legal Agent Team
+ st.session_state.legal_team = Agent(
+ name="Legal Team Lead",
+ role="Legal team coordinator",
+ model=OpenAIChat(id="gpt-4o"),
+ team=[legal_researcher, contract_analyst, legal_strategist],
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Coordinate analysis between team members",
+ "Provide comprehensive responses",
+ "Ensure all recommendations are properly sourced",
+ "Reference specific parts of the uploaded document",
+ "Always search the knowledge base before delegating tasks"
+ ],
+ show_tool_calls=True,
+ markdown=True
+ )
+
+ st.success("โ
Document processed and team initialized!")
+
+ except Exception as e:
+ st.error(f"Error processing document: {str(e)}")
+ else:
+ # File already processed, just show a message
+ st.success("โ
Document already processed and team ready!")
+
+ st.divider()
+ st.header("๐ Analysis Options")
+ analysis_type = st.selectbox(
+ "Select Analysis Type",
+ [
+ "Contract Review",
+ "Legal Research",
+ "Risk Assessment",
+ "Compliance Check",
+ "Custom Query"
+ ]
+ )
+ else:
+ st.warning("Please configure all API credentials to proceed")
+
+ # Main content area
+ if not all([st.session_state.openai_api_key, st.session_state.vector_db]):
+ st.info("๐ Please configure your API credentials in the sidebar to begin")
+ elif not uploaded_file:
+ st.info("๐ Please upload a legal document to begin analysis")
+ elif st.session_state.legal_team:
+ # Create a dictionary for analysis type icons
+ analysis_icons = {
+ "Contract Review": "๐",
+ "Legal Research": "๐",
+ "Risk Assessment": "โ ๏ธ",
+ "Compliance Check": "โ
",
+ "Custom Query": "๐ญ"
+ }
+
+ # Dynamic header with icon
+ st.header(f"{analysis_icons[analysis_type]} {analysis_type} Analysis")
+
+ analysis_configs = {
+ "Contract Review": {
+ "query": "Review this contract and identify key terms, obligations, and potential issues.",
+ "agents": ["Contract Analyst"],
+ "description": "Detailed contract analysis focusing on terms and obligations"
+ },
+ "Legal Research": {
+ "query": "Research relevant cases and precedents related to this document.",
+ "agents": ["Legal Researcher"],
+ "description": "Research on relevant legal cases and precedents"
+ },
+ "Risk Assessment": {
+ "query": "Analyze potential legal risks and liabilities in this document.",
+ "agents": ["Contract Analyst", "Legal Strategist"],
+ "description": "Combined risk analysis and strategic assessment"
+ },
+ "Compliance Check": {
+ "query": "Check this document for regulatory compliance issues.",
+ "agents": ["Legal Researcher", "Contract Analyst", "Legal Strategist"],
+ "description": "Comprehensive compliance analysis"
+ },
+ "Custom Query": {
+ "query": None,
+ "agents": ["Legal Researcher", "Contract Analyst", "Legal Strategist"],
+ "description": "Custom analysis using all available agents"
+ }
+ }
+
+ st.info(f"๐ {analysis_configs[analysis_type]['description']}")
+ st.write(f"๐ค Active Legal AI Agents: {', '.join(analysis_configs[analysis_type]['agents'])}") #dictionary!!
+
+ # Replace the existing user_query section with this:
+ if analysis_type == "Custom Query":
+ user_query = st.text_area(
+ "Enter your specific query:",
+ help="Add any specific questions or points you want to analyze"
+ )
+ else:
+ user_query = None # Set to None for non-custom queries
+
+
+ if st.button("Analyze"):
+ if analysis_type == "Custom Query" and not user_query:
+ st.warning("Please enter a query")
+ else:
+ with st.spinner("Analyzing document..."):
+ try:
+ # Ensure OpenAI API key is set
+ os.environ['OPENAI_API_KEY'] = st.session_state.openai_api_key
+
+ # Combine predefined and user queries
+ if analysis_type != "Custom Query":
+ combined_query = f"""
+ Using the uploaded document as reference:
+
+ Primary Analysis Task: {analysis_configs[analysis_type]['query']}
+ Focus Areas: {', '.join(analysis_configs[analysis_type]['agents'])}
+
+ Please search the knowledge base and provide specific references from the document.
+ """
+ else:
+ combined_query = f"""
+ Using the uploaded document as reference:
+
+ {user_query}
+
+ Please search the knowledge base and provide specific references from the document.
+ Focus Areas: {', '.join(analysis_configs[analysis_type]['agents'])}
+ """
+
+ response = st.session_state.legal_team.run(combined_query)
+
+ # Display results in tabs
+ tabs = st.tabs(["Analysis", "Key Points", "Recommendations"])
+
+ with tabs[0]:
+ st.markdown("### Detailed Analysis")
+ if response.content:
+ st.markdown(response.content)
+ else:
+ for message in response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ with tabs[1]:
+ st.markdown("### Key Points")
+ key_points_response = st.session_state.legal_team.run(
+ f"""Based on this previous analysis:
+ {response.content}
+
+ Please summarize the key points in bullet points.
+ Focus on insights from: {', '.join(analysis_configs[analysis_type]['agents'])}"""
+ )
+ if key_points_response.content:
+ st.markdown(key_points_response.content)
+ else:
+ for message in key_points_response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ with tabs[2]:
+ st.markdown("### Recommendations")
+ recommendations_response = st.session_state.legal_team.run(
+ f"""Based on this previous analysis:
+ {response.content}
+
+ What are your key recommendations based on the analysis, the best course of action?
+ Provide specific recommendations from: {', '.join(analysis_configs[analysis_type]['agents'])}"""
+ )
+ if recommendations_response.content:
+ st.markdown(recommendations_response.content)
+ else:
+ for message in recommendations_response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ except Exception as e:
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.info("Please upload a legal document to begin analysis")
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/README.md b/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/local_legal_agent.py b/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/local_legal_agent.py
new file mode 100644
index 0000000..16c0e8f
--- /dev/null
+++ b/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/local_legal_agent.py
@@ -0,0 +1,278 @@
+import streamlit as st
+from agno.agent import Agent
+from agno.knowledge.pdf import PDFKnowledgeBase, PDFReader
+from agno.vectordb.qdrant import Qdrant
+from agno.models.ollama import Ollama
+from agno.embedder.ollama import OllamaEmbedder
+import tempfile
+import os
+
+def init_session_state():
+ if 'vector_db' not in st.session_state:
+ st.session_state.vector_db = None
+ if 'legal_team' not in st.session_state:
+ st.session_state.legal_team = None
+ if 'knowledge_base' not in st.session_state:
+ st.session_state.knowledge_base = None
+
+def init_qdrant():
+ """Initialize local Qdrant vector database"""
+ return Qdrant(
+ collection="legal_knowledge",
+ url="http://localhost:6333",
+ embedder=OllamaEmbedder(model="openhermes")
+ )
+
+def process_document(uploaded_file, vector_db: Qdrant):
+ """Process document using local resources"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ temp_file_path = os.path.join(temp_dir, uploaded_file.name)
+ with open(temp_file_path, "wb") as f:
+ f.write(uploaded_file.getbuffer())
+
+ try:
+ st.write("Processing document...")
+ # Create knowledge base with local embedder
+ knowledge_base = PDFKnowledgeBase(
+ path=temp_dir,
+ vector_db=vector_db,
+ reader=PDFReader(chunk=True),
+ recreate_vector_db=True
+ )
+
+ st.write("Loading knowledge base...")
+ knowledge_base.load()
+
+ # Verify knowledge base
+ st.write("Verifying knowledge base...")
+ test_results = knowledge_base.search("test")
+ if not test_results:
+ raise Exception("Knowledge base verification failed")
+
+ st.write("Knowledge base ready!")
+ return knowledge_base
+
+ except Exception as e:
+ raise Exception(f"Error processing document: {str(e)}")
+
+def main():
+ st.set_page_config(page_title="Local Legal Document Analyzer", layout="wide")
+ init_session_state()
+
+ st.title("Local AI Legal Agent Team")
+
+ # Initialize local Qdrant
+ if not st.session_state.vector_db:
+ try:
+ st.session_state.vector_db = init_qdrant()
+ st.success("Connected to local Qdrant!")
+ except Exception as e:
+ st.error(f"Failed to connect to Qdrant: {str(e)}")
+ return
+
+ # Document upload section
+ st.header("๐ Document Upload")
+ uploaded_file = st.file_uploader("Upload Legal Document", type=['pdf'])
+
+ if uploaded_file:
+ with st.spinner("Processing document..."):
+ try:
+ knowledge_base = process_document(uploaded_file, st.session_state.vector_db)
+ st.session_state.knowledge_base = knowledge_base
+
+ # Initialize agents with Llama model
+ legal_researcher = Agent(
+ name="Legal Researcher",
+ role="Legal research specialist",
+ model=Ollama(id="llama3.1:8b"),
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Find and cite relevant legal cases and precedents",
+ "Provide detailed research summaries with sources",
+ "Reference specific sections from the uploaded document"
+ ],
+ markdown=True
+ )
+
+ contract_analyst = Agent(
+ name="Contract Analyst",
+ role="Contract analysis specialist",
+ model=Ollama(id="llama3.1:8b"),
+ knowledge=knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Review contracts thoroughly",
+ "Identify key terms and potential issues",
+ "Reference specific clauses from the document"
+ ],
+ markdown=True
+ )
+
+ legal_strategist = Agent(
+ name="Legal Strategist",
+ role="Legal strategy specialist",
+ model=Ollama(id="llama3.1:8b"),
+ knowledge=knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Develop comprehensive legal strategies",
+ "Provide actionable recommendations",
+ "Consider both risks and opportunities"
+ ],
+ markdown=True
+ )
+
+ # Legal Agent Team
+ st.session_state.legal_team = Agent(
+ name="Legal Team Lead",
+ role="Legal team coordinator",
+ model=Ollama(id="llama3.1:8b"),
+ team=[legal_researcher, contract_analyst, legal_strategist],
+ knowledge=st.session_state.knowledge_base,
+ search_knowledge=True,
+ instructions=[
+ "Coordinate analysis between team members",
+ "Provide comprehensive responses",
+ "Ensure all recommendations are properly sourced",
+ "Reference specific parts of the uploaded document"
+ ],
+ markdown=True
+ )
+
+ st.success("โ
Document processed and team initialized!")
+
+ except Exception as e:
+ st.error(f"Error processing document: {str(e)}")
+
+ st.divider()
+ st.header("๐ Analysis Options")
+ analysis_type = st.selectbox(
+ "Select Analysis Type",
+ [
+ "Contract Review",
+ "Legal Research",
+ "Risk Assessment",
+ "Compliance Check",
+ "Custom Query"
+ ]
+ )
+
+ # Main content area
+ if not st.session_state.vector_db:
+ st.info("๐ Waiting for Qdrant connection...")
+ elif not uploaded_file:
+ st.info("๐ Please upload a legal document to begin analysis")
+ elif st.session_state.legal_team:
+ st.header("Document Analysis")
+
+ analysis_configs = {
+ "Contract Review": {
+ "query": "Review this contract and identify key terms, obligations, and potential issues.",
+ "agents": ["Contract Analyst"],
+ "description": "Detailed contract analysis focusing on terms and obligations"
+ },
+ "Legal Research": {
+ "query": "Research relevant cases and precedents related to this document.",
+ "agents": ["Legal Researcher"],
+ "description": "Research on relevant legal cases and precedents"
+ },
+ "Risk Assessment": {
+ "query": "Analyze potential legal risks and liabilities in this document.",
+ "agents": ["Contract Analyst", "Legal Strategist"],
+ "description": "Combined risk analysis and strategic assessment"
+ },
+ "Compliance Check": {
+ "query": "Check this document for regulatory compliance issues.",
+ "agents": ["Legal Researcher", "Contract Analyst", "Legal Strategist"],
+ "description": "Comprehensive compliance analysis"
+ },
+ "Custom Query": {
+ "query": None,
+ "agents": ["Legal Researcher", "Contract Analyst", "Legal Strategist"],
+ "description": "Custom analysis using all available agents"
+ }
+ }
+
+ st.info(f"๐ {analysis_configs[analysis_type]['description']}")
+ st.write(f"๐ค Active Agents: {', '.join(analysis_configs[analysis_type]['agents'])}")
+
+ user_query = st.text_area(
+ "Enter your specific query:",
+ help="Add any specific questions or points you want to analyze"
+ )
+
+ if st.button("Analyze"):
+ if user_query or analysis_type != "Custom Query":
+ with st.spinner("Analyzing document..."):
+ try:
+ # Combine predefined and user queries
+ if analysis_type != "Custom Query":
+ combined_query = f"""
+ Using the uploaded document as reference:
+
+ Primary Analysis Task: {analysis_configs[analysis_type]['query']}
+ Additional User Query: {user_query if user_query else 'None'}
+
+ Focus Areas: {', '.join(analysis_configs[analysis_type]['agents'])}
+
+ Please search the knowledge base and provide specific references from the document.
+ """
+ else:
+ combined_query = user_query
+
+ response = st.session_state.legal_team.run(combined_query)
+
+ # Display results in tabs
+ tabs = st.tabs(["Analysis", "Key Points", "Recommendations"])
+
+ with tabs[0]:
+ st.markdown("### Detailed Analysis")
+ if response.content:
+ st.markdown(response.content)
+ else:
+ for message in response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ with tabs[1]:
+ st.markdown("### Key Points")
+ key_points_response = st.session_state.legal_team.run(
+ f"""Based on this previous analysis:
+ {response.content}
+
+ Please summarize the key points in bullet points.
+ Focus on insights from: {', '.join(analysis_configs[analysis_type]['agents'])}"""
+ )
+ if key_points_response.content:
+ st.markdown(key_points_response.content)
+ else:
+ for message in key_points_response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ with tabs[2]:
+ st.markdown("### Recommendations")
+ recommendations_response = st.session_state.legal_team.run(
+ f"""Based on this previous analysis:
+ {response.content}
+
+ What are your key recommendations based on the analysis, the best course of action?
+ Provide specific recommendations from: {', '.join(analysis_configs[analysis_type]['agents'])}"""
+ )
+ if recommendations_response.content:
+ st.markdown(recommendations_response.content)
+ else:
+ for message in recommendations_response.messages:
+ if message.role == 'assistant' and message.content:
+ st.markdown(message.content)
+
+ except Exception as e:
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.warning("Please enter a query or select an analysis type")
+ else:
+ st.info("Please upload a legal document to begin analysis")
+
+if __name__ == "__main__":
+ main()
diff --git a/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/requirements.txt b/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/requirements.txt
new file mode 100644
index 0000000..e23a639
--- /dev/null
+++ b/ai_agent_tutorials/ai_legal_agent_team/local_ai_legal_agent_team/requirements.txt
@@ -0,0 +1,4 @@
+agno
+streamlit==1.40.2
+qdrant-client==1.12.1
+ollama==0.4.4
diff --git a/ai_agent_tutorials/ai_legal_agent_team/requirements.txt b/ai_agent_tutorials/ai_legal_agent_team/requirements.txt
new file mode 100644
index 0000000..c6cda18
--- /dev/null
+++ b/ai_agent_tutorials/ai_legal_agent_team/requirements.txt
@@ -0,0 +1,6 @@
+agno
+streamlit==1.40.2
+qdrant-client==1.12.1
+openai
+pypdf
+duckduckgo-search
diff --git a/ai_agent_tutorials/ai_medical_imaging_agent/README.md b/ai_agent_tutorials/ai_medical_imaging_agent/README.md
new file mode 100644
index 0000000..57801ff
--- /dev/null
+++ b/ai_agent_tutorials/ai_medical_imaging_agent/README.md
@@ -0,0 +1,66 @@
+# ๐ฉป Medical Imaging Diagnosis Agent
+
+A Medical Imaging Diagnosis Agent build on agno powered by Gemini 2.0 Flash that provides AI-assisted analysis of medical images of various scans. The agent acts as a medical imaging diagnosis expert to analyze various types of medical images and videos, providing detailed diagnostic insights and explanations.
+
+## Features
+
+- **Comprehensive Image Analysis**
+ - Image Type Identification (X-ray, MRI, CT scan, ultrasound)
+ - Anatomical Region Detection
+ - Key Findings and Observations
+ - Potential Abnormalities Detection
+ - Image Quality Assessment
+ - Research and Reference
+
+## How to Run
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_medical_imaging_agent
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+2. **Configure API Keys**
+ - Get Google API key from [Google AI Studio](https://aistudio.google.com)
+
+3. **Run the Application**
+ ```bash
+ streamlit run ai_medical_imaging.py
+ ```
+
+## Analysis Components
+
+- **Image Type and Region**
+ - Identifies imaging modality
+ - Specifies anatomical region
+
+- **Key Findings**
+ - Systematic listing of observations
+ - Detailed appearance descriptions
+ - Abnormality highlighting
+
+- **Diagnostic Assessment**
+ - Potential diagnoses ranking
+ - Differential diagnoses
+ - Severity assessment
+
+- **Patient-Friendly Explanations**
+ - Simplified terminology
+ - Detailed first-principles explanations
+ - Visual reference points
+
+## Notes
+
+- Uses Gemini 2.0 Flash for analysis
+- Requires stable internet connection
+- Free API usage costs - 1,500 free requests per day by google!
+- For educational and development purposes only
+- Not a replacement for professional medical diagnosis
+
+## Disclaimer
+
+This tool is for educational and informational purposes only. All analyses should be reviewed by qualified healthcare professionals. Do not make medical decisions based solely on this analysis.
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_medical_imaging_agent/ai_medical_imaging.py b/ai_agent_tutorials/ai_medical_imaging_agent/ai_medical_imaging.py
new file mode 100644
index 0000000..b02d79e
--- /dev/null
+++ b/ai_agent_tutorials/ai_medical_imaging_agent/ai_medical_imaging.py
@@ -0,0 +1,156 @@
+import os
+from PIL import Image as PILImage
+from agno.agent import Agent
+from agno.models.google import Gemini
+import streamlit as st
+from agno.tools.duckduckgo import DuckDuckGoTools
+from agno.media import Image as AgnoImage
+
+if "GOOGLE_API_KEY" not in st.session_state:
+ st.session_state.GOOGLE_API_KEY = None
+
+with st.sidebar:
+ st.title("โน๏ธ Configuration")
+
+ if not st.session_state.GOOGLE_API_KEY:
+ api_key = st.text_input(
+ "Enter your Google API Key:",
+ type="password"
+ )
+ st.caption(
+ "Get your API key from [Google AI Studio]"
+ "(https://aistudio.google.com/apikey) ๐"
+ )
+ if api_key:
+ st.session_state.GOOGLE_API_KEY = api_key
+ st.success("API Key saved!")
+ st.rerun()
+ else:
+ st.success("API Key is configured")
+ if st.button("๐ Reset API Key"):
+ st.session_state.GOOGLE_API_KEY = None
+ st.rerun()
+
+ st.info(
+ "This tool provides AI-powered analysis of medical imaging data using "
+ "advanced computer vision and radiological expertise."
+ )
+ st.warning(
+ "โ DISCLAIMER: This tool is for educational and informational purposes only. "
+ "All analyses should be reviewed by qualified healthcare professionals. "
+ "Do not make medical decisions based solely on this analysis."
+ )
+
+medical_agent = Agent(
+ model=Gemini(
+ id="gemini-2.0-flash",
+ api_key=st.session_state.GOOGLE_API_KEY
+ ),
+ tools=[DuckDuckGoTools()],
+ markdown=True
+) if st.session_state.GOOGLE_API_KEY else None
+
+if not medical_agent:
+ st.warning("Please configure your API key in the sidebar to continue")
+
+# Medical Analysis Query
+query = """
+You are a highly skilled medical imaging expert with extensive knowledge in radiology and diagnostic imaging. Analyze the patient's medical image and structure your response as follows:
+
+### 1. Image Type & Region
+- Specify imaging modality (X-ray/MRI/CT/Ultrasound/etc.)
+- Identify the patient's anatomical region and positioning
+- Comment on image quality and technical adequacy
+
+### 2. Key Findings
+- List primary observations systematically
+- Note any abnormalities in the patient's imaging with precise descriptions
+- Include measurements and densities where relevant
+- Describe location, size, shape, and characteristics
+- Rate severity: Normal/Mild/Moderate/Severe
+
+### 3. Diagnostic Assessment
+- Provide primary diagnosis with confidence level
+- List differential diagnoses in order of likelihood
+- Support each diagnosis with observed evidence from the patient's imaging
+- Note any critical or urgent findings
+
+### 4. Patient-Friendly Explanation
+- Explain the findings in simple, clear language that the patient can understand
+- Avoid medical jargon or provide clear definitions
+- Include visual analogies if helpful
+- Address common patient concerns related to these findings
+
+### 5. Research Context
+IMPORTANT: Use the DuckDuckGo search tool to:
+- Find recent medical literature about similar cases
+- Search for standard treatment protocols
+- Provide a list of relevant medical links of them too
+- Research any relevant technological advances
+- Include 2-3 key references to support your analysis
+
+Format your response using clear markdown headers and bullet points. Be concise yet thorough.
+"""
+
+st.title("๐ฅ Medical Imaging Diagnosis Agent")
+st.write("Upload a medical image for professional analysis")
+
+# Create containers for better organization
+upload_container = st.container()
+image_container = st.container()
+analysis_container = st.container()
+
+with upload_container:
+ uploaded_file = st.file_uploader(
+ "Upload Medical Image",
+ type=["jpg", "jpeg", "png", "dicom"],
+ help="Supported formats: JPG, JPEG, PNG, DICOM"
+ )
+
+if uploaded_file is not None:
+ with image_container:
+ col1, col2, col3 = st.columns([1, 2, 1])
+ with col2:
+ image = PILImage.open(uploaded_file)
+ width, height = image.size
+ aspect_ratio = width / height
+ new_width = 500
+ new_height = int(new_width / aspect_ratio)
+ resized_image = image.resize((new_width, new_height))
+
+ st.image(
+ resized_image,
+ caption="Uploaded Medical Image",
+ use_container_width=True
+ )
+
+ analyze_button = st.button(
+ "๐ Analyze Image",
+ type="primary",
+ use_container_width=True
+ )
+
+ with analysis_container:
+ if analyze_button:
+ with st.spinner("๐ Analyzing image... Please wait."):
+ try:
+ temp_path = "temp_resized_image.png"
+ resized_image.save(temp_path)
+
+ # Create AgnoImage object
+ agno_image = AgnoImage(filepath=temp_path) # Adjust if constructor differs
+
+ # Run analysis
+ response = medical_agent.run(query, images=[agno_image])
+ st.markdown("### ๐ Analysis Results")
+ st.markdown("---")
+ st.markdown(response.content)
+ st.markdown("---")
+ st.caption(
+ "Note: This analysis is generated by AI and should be reviewed by "
+ "a qualified healthcare professional."
+ )
+ except Exception as e:
+ st.error(f"Analysis error: {e}")
+else:
+ st.info("๐ Please upload a medical image to begin analysis")
diff --git a/ai_agent_tutorials/ai_medical_imaging_agent/requirements.txt b/ai_agent_tutorials/ai_medical_imaging_agent/requirements.txt
new file mode 100644
index 0000000..9eb6d27
--- /dev/null
+++ b/ai_agent_tutorials/ai_medical_imaging_agent/requirements.txt
@@ -0,0 +1,5 @@
+streamlit==1.40.2
+agno
+Pillow==10.0.0
+duckduckgo-search==6.4.1
+google-generativeai==0.8.3
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_meeting_agent/README.md b/ai_agent_tutorials/ai_meeting_agent/README.md
index dfa738c..b93679b 100644
--- a/ai_agent_tutorials/ai_meeting_agent/README.md
+++ b/ai_agent_tutorials/ai_meeting_agent/README.md
@@ -14,6 +14,7 @@ This Streamlit application leverages multiple AI agents to create comprehensive
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_meeting_agent
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/ai_meeting_agent/meeting_agent.py b/ai_agent_tutorials/ai_meeting_agent/meeting_agent.py
index d9d7e70..652935c 100644
--- a/ai_agent_tutorials/ai_meeting_agent/meeting_agent.py
+++ b/ai_agent_tutorials/ai_meeting_agent/meeting_agent.py
@@ -1,7 +1,6 @@
import streamlit as st
-from crewai import Agent, Task, Crew, Process
-from langchain_openai import ChatOpenAI
-from langchain_anthropic import ChatAnthropic
+from crewai import Agent, Task, Crew, LLM
+from crewai.process import Process
from crewai_tools import SerperDevTool
import os
@@ -11,20 +10,16 @@ st.title("AI Meeting Preparation Agent ๐")
# Sidebar for API keys
st.sidebar.header("API Keys")
-openai_api_key = st.sidebar.text_input("OpenAI API Key", type="password")
anthropic_api_key = st.sidebar.text_input("Anthropic API Key", type="password")
serper_api_key = st.sidebar.text_input("Serper API Key", type="password")
# Check if all API keys are set
-if openai_api_key and anthropic_api_key and serper_api_key:
- # Set API keys as environment variables
- os.environ["OPENAI_API_KEY"] = openai_api_key
+if anthropic_api_key and serper_api_key:
+ # # Set API keys as environment variables
os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
os.environ["SERPER_API_KEY"] = serper_api_key
- # Initialize the AI models and tools
- gpt4 = ChatOpenAI(model_name="gpt-4o-mini")
- claude = ChatAnthropic(model_name="claude-3-5-sonnet-20240620")
+ claude = LLM(model="claude-3-5-sonnet-20240620", temperature= 0.7, api_key=anthropic_api_key)
search_tool = SerperDevTool()
# Input fields
@@ -41,7 +36,7 @@ if openai_api_key and anthropic_api_key and serper_api_key:
backstory='You are an expert at quickly understanding complex business contexts and identifying critical information.',
verbose=True,
allow_delegation=False,
- llm=gpt4,
+ llm=claude,
tools=[search_tool]
)
@@ -51,7 +46,7 @@ if openai_api_key and anthropic_api_key and serper_api_key:
backstory='You are a seasoned industry analyst with a knack for spotting emerging trends and opportunities.',
verbose=True,
allow_delegation=False,
- llm=gpt4,
+ llm=claude,
tools=[search_tool]
)
diff --git a/ai_agent_tutorials/ai_meme_generator_agent_browseruse/README.md b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/README.md
new file mode 100644
index 0000000..ee3dd35
--- /dev/null
+++ b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/README.md
@@ -0,0 +1,51 @@
+# ๐ฅธ AI Meme Generator Agent - Browser Use
+
+The AI Meme Generator Agent is a powerful browser automation tool that creates memes using AI agents. This app combines multi-LLM capabilities with automated browser interactions to generate memes based on text prompts through direct website manipulation.
+
+## Features
+
+- **Multi-LLM Support**
+ - Claude 3.5 Sonnet (Anthropic)
+ - GPT-4o (OpenAI)
+ - Deepseek v3 (Deepseek)
+ - Automatic model switching with API key validation
+
+- **Browser Automation**:
+ - Direct interaction with imgflip.com meme templates
+ - Automated search for relevant meme formats
+ - Dynamic text insertion for top/bottom captions
+ - Image link extraction from generated memes
+
+- **Smart Generation Workflow**:
+ - Action verb extraction from prompts
+ - Metaphorical template matching
+ - Multi-step quality validation
+ - Automatic retry mechanism for failed generations
+
+- **User-Friendly Interface**:
+ - Model configuration sidebar
+ - API key management
+ - Direct meme preview with clickable links
+ - Responsive error handling
+
+
+API keys required:
+- **Anthropic** (for Claude)
+- **Deepseek**
+- **OpenAI** (for GPT-4o)
+
+## How to Run
+
+1. **Clone the Repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_meme_generator_browseruse
+ ```
+2. **Install the dependencies**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+3. **Run the Streamlit app**:
+ ```bash
+ streamlit run ai_meme_generator.py
+ ```
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_meme_generator_agent_browseruse/ai_meme_generator_agent.py b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/ai_meme_generator_agent.py
new file mode 100644
index 0000000..23a8821
--- /dev/null
+++ b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/ai_meme_generator_agent.py
@@ -0,0 +1,130 @@
+import asyncio
+import streamlit as st
+from browser_use import Agent, SystemPrompt
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain_core.messages import HumanMessage
+import re
+
+async def generate_meme(query: str, model_choice: str, api_key: str) -> None:
+ # Initialize the appropriate LLM based on user selection
+ if model_choice == "Claude":
+ llm = ChatAnthropic(
+ model="claude-3-5-sonnet-20241022",
+ api_key=api_key
+ )
+ elif model_choice == "Deepseek":
+ llm = ChatOpenAI(
+ base_url='https://api.deepseek.com/v1',
+ model='deepseek-chat',
+ api_key=api_key,
+ temperature=0.3
+ )
+ else: # OpenAI
+ llm = ChatOpenAI(
+ model="gpt-4o",
+ api_key=api_key,
+ temperature=0.0
+ )
+
+ task_description = (
+ "You are a meme generator expert. You are given a query and you need to generate a meme for it.\n"
+ "1. Go to https://imgflip.com/memetemplates \n"
+ "2. Click on the Search bar in the middle and search for ONLY ONE MAIN ACTION VERB (like 'bully', 'laugh', 'cry') in this query: '{0}'\n"
+ "3. Choose any meme template that metaphorically fits the meme topic: '{0}'\n"
+ " by clicking on the 'Add Caption' button below it\n"
+ "4. Write a Top Text (setup/context) and Bottom Text (punchline/outcome) related to '{0}'.\n"
+ "5. Check the preview making sure it is funny and a meaningful meme. Adjust text directly if needed. \n"
+ "6. Look at the meme and text on it, if it doesnt make sense, PLEASE retry by filling the text boxes with different text. \n"
+ "7. Click on the Generate meme button to generate the meme\n"
+ "8. Copy the image link and give it as the output\n"
+ ).format(query)
+
+ agent = Agent(
+ task=task_description,
+ llm=llm,
+ max_actions_per_step=5,
+ max_failures=25,
+ use_vision=(model_choice != "Deepseek")
+ )
+
+ history = await agent.run()
+
+ # Extract final result from agent history
+ final_result = history.final_result()
+
+ # Use regex to find the meme URL in the result
+ url_match = re.search(r'https://imgflip\.com/i/(\w+)', final_result)
+ if url_match:
+ meme_id = url_match.group(1)
+ return f"https://i.imgflip.com/{meme_id}.jpg"
+ return None
+
+def main():
+ # Custom CSS styling
+
+
+ st.title("๐ฅธ AI Meme Generator Agent - Browser Use")
+ st.info("This AI browser agent does browser automation to generate memes based on your input with browser use. Please enter your API key and describe the meme you want to generate.")
+
+ # Sidebar configuration
+ with st.sidebar:
+ st.markdown('', unsafe_allow_html=True)
+
+ # Model selection
+ model_choice = st.selectbox(
+ "Select AI Model",
+ ["Claude", "Deepseek", "OpenAI"],
+ index=0,
+ help="Choose which LLM to use for meme generation"
+ )
+
+ # API key input based on model selection
+ api_key = ""
+ if model_choice == "Claude":
+ api_key = st.text_input("Claude API Key", type="password",
+ help="Get your API key from https://console.anthropic.com")
+ elif model_choice == "Deepseek":
+ api_key = st.text_input("Deepseek API Key", type="password",
+ help="Get your API key from https://platform.deepseek.com")
+ else:
+ api_key = st.text_input("OpenAI API Key", type="password",
+ help="Get your API key from https://platform.openai.com")
+
+ # Main content area
+ st.markdown('', unsafe_allow_html=True)
+
+ query = st.text_input(
+ "Meme Idea Input",
+ placeholder="Example: 'Ilya's SSI quietly looking at the OpenAI vs Deepseek debate while diligently working on ASI'",
+ label_visibility="collapsed"
+ )
+
+ if st.button("Generate Meme ๐"):
+ if not api_key:
+ st.warning(f"Please provide the {model_choice} API key")
+ st.stop()
+ if not query:
+ st.warning("Please enter a meme idea")
+ st.stop()
+
+ with st.spinner(f"๐ง {model_choice} is generating your meme..."):
+ try:
+ meme_url = asyncio.run(generate_meme(query, model_choice, api_key))
+
+ if meme_url:
+ st.success("โ
Meme Generated Successfully!")
+ st.image(meme_url, caption="Generated Meme Preview", use_container_width=True)
+ st.markdown(f"""
+ **Direct Link:** [Open in ImgFlip]({meme_url})
+ **Embed URL:** `{meme_url}`
+ """)
+ else:
+ st.error("โ Failed to generate meme. Please try again with a different prompt.")
+
+ except Exception as e:
+ st.error(f"Error: {str(e)}")
+ st.info("๐ก If using OpenAI, ensure your account has GPT-4o access")
+
+if __name__ == '__main__':
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_meme_generator_agent_browseruse/requirements.txt b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/requirements.txt
new file mode 100644
index 0000000..0918b46
--- /dev/null
+++ b/ai_agent_tutorials/ai_meme_generator_agent_browseruse/requirements.txt
@@ -0,0 +1,6 @@
+streamlit
+browser-use==0.1.26
+playwright==1.49.1
+langchain-openai
+langchain-anthropic
+asyncio
diff --git a/ai_agent_tutorials/ai_mental_wellbeing_agent/README.md b/ai_agent_tutorials/ai_mental_wellbeing_agent/README.md
new file mode 100644
index 0000000..a70b0bc
--- /dev/null
+++ b/ai_agent_tutorials/ai_mental_wellbeing_agent/README.md
@@ -0,0 +1,73 @@
+# AI Mental Wellbeing Agent Team ๐ง
+
+The AI Mental Wellbeing Agent Team is a supportive mental health assessment and guidance system powered by [AG2](https://github.com/ag2ai/ag2?tab=readme-ov-file)(formerly AutoGen)'s AI Agent framework. This app provides personalized mental health support through the coordination of specialized AI agents, each focusing on different aspects of mental health care based on user inputs such as emotional state, stress levels, sleep patterns, and current symptoms. This is built on AG2's new swarm feature run through initiate_swarm_chat() method.
+
+## Features
+
+- **Specialized Mental Wellbeing Support Team**
+ - ๐ง **Assessment Agent**: Analyzes emotional state and psychological needs with clinical precision and empathy
+ - ๐ฏ **Action Agent**: Creates immediate action plans and connects users with appropriate resources
+ - ๐ **Follow-up Agent**: Designs long-term support strategies and prevention plans
+
+- **Comprehensive Mental Wellbeing Support**:
+ - Detailed psychological assessment
+ - Immediate coping strategies
+ - Resource recommendations
+ - Long-term support planning
+ - Crisis prevention strategies
+ - Progress monitoring systems
+
+- **Customizable Input Parameters**:
+ - Current emotional state
+ - Sleep patterns
+ - Stress levels
+ - Support system information
+ - Recent life changes
+ - Current symptoms
+
+- **Interactive Results**:
+ - Real-time assessment summaries
+ - Detailed recommendations in expandable sections
+ - Clear action steps and resources
+ - Long-term support strategies
+
+## How to Run
+
+Follow these steps to set up and run the application:
+
+1. **Clone the Repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_mental_wellbeing_agent
+ ```
+
+2. **Install Dependencies**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+
+3. **Create Environment File**:
+ Create a `.env` file in the project directory:
+ ```bash
+ echo "AUTOGEN_USE_DOCKER=0" > .env
+ ```
+ This disables Docker requirement for code execution in AutoGen.
+
+4. **Set Up OpenAI API Key**:
+ - Obtain an OpenAI API key from [OpenAI's platform](https://platform.openai.com)
+ - You'll input this key in the app's sidebar when running
+
+5. **Run the Streamlit App**:
+ ```bash
+ streamlit run ai_mental_wellbeing_agent.py
+ ```
+
+
+## โ ๏ธ Important Notice
+
+This application is a supportive tool and does not replace professional mental health care. If you're experiencing thoughts of self-harm or severe crisis:
+
+- Call National Crisis Hotline: 988
+- Call Emergency Services: 911
+- Seek immediate professional help
+
diff --git a/ai_agent_tutorials/ai_mental_wellbeing_agent/ai_mental_wellbeing_agent.py b/ai_agent_tutorials/ai_mental_wellbeing_agent/ai_mental_wellbeing_agent.py
new file mode 100644
index 0000000..2210743
--- /dev/null
+++ b/ai_agent_tutorials/ai_mental_wellbeing_agent/ai_mental_wellbeing_agent.py
@@ -0,0 +1,226 @@
+import streamlit as st
+from autogen import (SwarmAgent, SwarmResult, initiate_swarm_chat, OpenAIWrapper,AFTER_WORK,UPDATE_SYSTEM_MESSAGE)
+import os
+
+os.environ["AUTOGEN_USE_DOCKER"] = "0"
+
+if 'output' not in st.session_state:
+ st.session_state.output = {
+ 'assessment': '',
+ 'action': '',
+ 'followup': ''
+ }
+
+st.sidebar.title("OpenAI API Key")
+api_key = st.sidebar.text_input("Enter your OpenAI API Key", type="password")
+
+st.sidebar.warning("""
+## โ ๏ธ Important Notice
+
+This application is a supportive tool and does not replace professional mental health care. If you're experiencing thoughts of self-harm or severe crisis:
+
+- Call National Crisis Hotline: 988
+- Call Emergency Services: 911
+- Seek immediate professional help
+""")
+
+st.title("๐ง Mental Wellbeing Agent")
+
+st.info("""
+**Meet Your Mental Wellbeing Agent Team:**
+
+๐ง **Assessment Agent** - Analyzes your situation and emotional needs
+๐ฏ **Action Agent** - Creates immediate action plan and connects you with resources
+๐ **Follow-up Agent** - Designs your long-term support strategy
+""")
+
+st.subheader("Personal Information")
+col1, col2 = st.columns(2)
+
+with col1:
+ mental_state = st.text_area("How have you been feeling recently?",
+ placeholder="Describe your emotional state, thoughts, or concerns...")
+ sleep_pattern = st.select_slider(
+ "Sleep Pattern (hours per night)",
+ options=[f"{i}" for i in range(0, 13)],
+ value="7"
+ )
+
+with col2:
+ stress_level = st.slider("Current Stress Level (1-10)", 1, 10, 5)
+ support_system = st.multiselect(
+ "Current Support System",
+ ["Family", "Friends", "Therapist", "Support Groups", "None"]
+ )
+
+recent_changes = st.text_area(
+ "Any significant life changes or events recently?",
+ placeholder="Job changes, relationships, losses, etc..."
+)
+
+current_symptoms = st.multiselect(
+ "Current Symptoms",
+ ["Anxiety", "Depression", "Insomnia", "Fatigue", "Loss of Interest",
+ "Difficulty Concentrating", "Changes in Appetite", "Social Withdrawal",
+ "Mood Swings", "Physical Discomfort"]
+)
+
+if st.button("Get Support Plan"):
+ if not api_key:
+ st.error("Please enter your OpenAI API key.")
+ else:
+ with st.spinner('๐ค AI Agents are analyzing your situation...'):
+ try:
+ task = f"""
+ Create a comprehensive mental health support plan based on:
+
+ Emotional State: {mental_state}
+ Sleep: {sleep_pattern} hours per night
+ Stress Level: {stress_level}/10
+ Support System: {', '.join(support_system) if support_system else 'None reported'}
+ Recent Changes: {recent_changes}
+ Current Symptoms: {', '.join(current_symptoms) if current_symptoms else 'None reported'}
+ """
+
+ system_messages = {
+ "assessment_agent": """
+ You are an experienced mental health professional speaking directly to the user. Your task is to:
+ 1. Create a safe space by acknowledging their courage in seeking support
+ 2. Analyze their emotional state with clinical precision and genuine empathy
+ 3. Ask targeted follow-up questions to understand their full situation
+ 4. Identify patterns in their thoughts, behaviors, and relationships
+ 5. Assess risk levels with validated screening approaches
+ 6. Help them understand their current mental health in accessible language
+ 7. Validate their experiences without minimizing or catastrophizing
+
+ Always use "you" and "your" when addressing the user. Blend clinical expertise with genuine warmth and never rush to conclusions.
+ """,
+
+ "action_agent": """
+ You are a crisis intervention and resource specialist speaking directly to the user. Your task is to:
+ 1. Provide immediate evidence-based coping strategies tailored to their specific situation
+ 2. Prioritize interventions based on urgency and effectiveness
+ 3. Connect them with appropriate mental health services while acknowledging barriers (cost, access, stigma)
+ 4. Create a concrete daily wellness plan with specific times and activities
+ 5. Suggest specific support communities with details on how to join
+ 6. Balance crisis resources with empowerment techniques
+ 7. Teach simple self-regulation techniques they can use immediately
+
+ Focus on practical, achievable steps that respect their current capacity and energy levels. Provide options ranging from minimal effort to more involved actions.
+ """,
+
+ "followup_agent": """
+ You are a mental health recovery planner speaking directly to the user. Your task is to:
+ 1. Design a personalized long-term support strategy with milestone markers
+ 2. Create a progress monitoring system that matches their preferences and habits
+ 3. Develop specific relapse prevention strategies based on their unique triggers
+ 4. Establish a support network mapping exercise to identify existing resources
+ 5. Build a graduated self-care routine that evolves with their recovery
+ 6. Plan for setbacks with self-compassion techniques
+ 7. Set up a maintenance schedule with clear check-in mechanisms
+
+ Focus on building sustainable habits that integrate with their lifestyle and values. Emphasize progress over perfection and teach skills for self-directed care.
+ """
+ }
+
+ llm_config = {
+ "config_list": [{"model": "gpt-4o", "api_key": api_key}]
+ }
+
+ context_variables = {
+ "assessment": None,
+ "action": None,
+ "followup": None,
+ }
+
+ def update_assessment_overview(assessment_summary: str, context_variables: dict) -> SwarmResult:
+ context_variables["assessment"] = assessment_summary
+ st.sidebar.success('Assessment: ' + assessment_summary)
+ return SwarmResult(agent="action_agent", context_variables=context_variables)
+
+ def update_action_overview(action_summary: str, context_variables: dict) -> SwarmResult:
+ context_variables["action"] = action_summary
+ st.sidebar.success('Action Plan: ' + action_summary)
+ return SwarmResult(agent="followup_agent", context_variables=context_variables)
+
+ def update_followup_overview(followup_summary: str, context_variables: dict) -> SwarmResult:
+ context_variables["followup"] = followup_summary
+ st.sidebar.success('Follow-up Strategy: ' + followup_summary)
+ return SwarmResult(agent="assessment_agent", context_variables=context_variables)
+
+ def update_system_message_func(agent: SwarmAgent, messages) -> str:
+ system_prompt = system_messages[agent.name]
+ current_gen = agent.name.split("_")[0]
+
+ if agent._context_variables.get(current_gen) is None:
+ system_prompt += f"Call the update function provided to first provide a 2-3 sentence summary of your ideas on {current_gen.upper()} based on the context provided."
+ agent.llm_config['tool_choice'] = {"type": "function", "function": {"name": f"update_{current_gen}_overview"}}
+ else:
+ agent.llm_config["tools"] = None
+ agent.llm_config['tool_choice'] = None
+ system_prompt += f"\n\nYour task\nYou task is write the {current_gen} part of the report. Do not include any other parts. Do not use XML tags.\nStart your reponse with: '## {current_gen.capitalize()} Design'."
+ k = list(agent._oai_messages.keys())[-1]
+ agent._oai_messages[k] = agent._oai_messages[k][:1]
+
+ system_prompt += f"\n\n\nBelow are some context for you to refer to:"
+ for k, v in agent._context_variables.items():
+ if v is not None:
+ system_prompt += f"\n{k.capitalize()} Summary:\n{v}"
+
+ agent.client = OpenAIWrapper(**agent.llm_config)
+ return system_prompt
+
+ state_update = UPDATE_SYSTEM_MESSAGE(update_system_message_func)
+
+ assessment_agent = SwarmAgent(
+ "assessment_agent",
+ llm_config=llm_config,
+ functions=update_assessment_overview,
+ update_agent_state_before_reply=[state_update]
+ )
+
+ action_agent = SwarmAgent(
+ "action_agent",
+ llm_config=llm_config,
+ functions=update_action_overview,
+ update_agent_state_before_reply=[state_update]
+ )
+
+ followup_agent = SwarmAgent(
+ "followup_agent",
+ llm_config=llm_config,
+ functions=update_followup_overview,
+ update_agent_state_before_reply=[state_update]
+ )
+
+ assessment_agent.register_hand_off(AFTER_WORK(action_agent))
+ action_agent.register_hand_off(AFTER_WORK(followup_agent))
+ followup_agent.register_hand_off(AFTER_WORK(assessment_agent))
+
+ result, _, _ = initiate_swarm_chat(
+ initial_agent=assessment_agent,
+ agents=[assessment_agent, action_agent, followup_agent],
+ user_agent=None,
+ messages=task,
+ max_rounds=13,
+ )
+
+ st.session_state.output = {
+ 'assessment': result.chat_history[-3]['content'],
+ 'action': result.chat_history[-2]['content'],
+ 'followup': result.chat_history[-1]['content']
+ }
+
+ with st.expander("Situation Assessment"):
+ st.markdown(st.session_state.output['assessment'])
+
+ with st.expander("Action Plan & Resources"):
+ st.markdown(st.session_state.output['action'])
+
+ with st.expander("Long-term Support Strategy"):
+ st.markdown(st.session_state.output['followup'])
+
+ st.success('โจ Mental health support plan generated successfully!')
+
+ except Exception as e:
+ st.error(f"An error occurred: {str(e)}")
diff --git a/ai_agent_tutorials/ai_mental_wellbeing_agent/requirements.txt b/ai_agent_tutorials/ai_mental_wellbeing_agent/requirements.txt
new file mode 100644
index 0000000..da4c21a
--- /dev/null
+++ b/ai_agent_tutorials/ai_mental_wellbeing_agent/requirements.txt
@@ -0,0 +1,4 @@
+autogen-agentchat
+autogen-ext
+pyautogen
+streamlit
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_movie_production_agent/README.md b/ai_agent_tutorials/ai_movie_production_agent/README.md
index 0a1bf8e..3dac2c7 100644
--- a/ai_agent_tutorials/ai_movie_production_agent/README.md
+++ b/ai_agent_tutorials/ai_movie_production_agent/README.md
@@ -12,6 +12,7 @@ This Streamlit app is an AI-powered movie production assistant that helps bring
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_movie_production_agent
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/ai_movie_production_agent/movie_production_agent.py b/ai_agent_tutorials/ai_movie_production_agent/movie_production_agent.py
index 064d2c2..b324bca 100644
--- a/ai_agent_tutorials/ai_movie_production_agent/movie_production_agent.py
+++ b/ai_agent_tutorials/ai_movie_production_agent/movie_production_agent.py
@@ -1,8 +1,8 @@
# Import the required libraries
import streamlit as st
-from phi.assistant import Assistant
-from phi.tools.serpapi_tools import SerpApiTools
-from phi.llm.anthropic import Claude
+from agno.agent import Agent
+from agno.tools.serpapi import SerpApiTools
+from agno.models.anthropic import Claude
from textwrap import dedent
# Set up the Streamlit app
@@ -15,9 +15,9 @@ anthropic_api_key = st.text_input("Enter Anthropic API Key to access Claude Sonn
serp_api_key = st.text_input("Enter Serp API Key for Search functionality", type="password")
if anthropic_api_key and serp_api_key:
- script_writer = Assistant(
+ script_writer = Agent(
name="ScriptWriter",
- llm=Claude(model="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
+ model=Claude(id="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
description=dedent(
"""\
You are an expert screenplay writer. Given a movie idea and genre,
@@ -31,9 +31,9 @@ if anthropic_api_key and serp_api_key:
],
)
- casting_director = Assistant(
+ casting_director = Agent(
name="CastingDirector",
- llm=Claude(model="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
+ model=Claude(id="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
description=dedent(
"""\
You are a talented casting director. Given a script outline and character descriptions,
@@ -49,9 +49,9 @@ if anthropic_api_key and serp_api_key:
tools=[SerpApiTools(api_key=serp_api_key)],
)
- movie_producer = Assistant(
+ movie_producer = Agent(
name="MovieProducer",
- llm=Claude(model="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
+ model=Claude(id="claude-3-5-sonnet-20240620", api_key=anthropic_api_key),
team=[script_writer, casting_director],
description="Experienced movie producer overseeing script and casting.",
instructions=[
diff --git a/ai_agent_tutorials/ai_movie_production_agent/requirements.txt b/ai_agent_tutorials/ai_movie_production_agent/requirements.txt
index 2c59945..fc46b55 100644
--- a/ai_agent_tutorials/ai_movie_production_agent/requirements.txt
+++ b/ai_agent_tutorials/ai_movie_production_agent/requirements.txt
@@ -1,5 +1,5 @@
streamlit
-phidata
+agno
anthropic
google-search-results
lxml_html_clean
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_personal_finance_agent/README.md b/ai_agent_tutorials/ai_personal_finance_agent/README.md
index 92683af..c96ae2b 100644
--- a/ai_agent_tutorials/ai_personal_finance_agent/README.md
+++ b/ai_agent_tutorials/ai_personal_finance_agent/README.md
@@ -12,6 +12,7 @@ This Streamlit app is an AI-powered personal finance planner that generates pers
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_personal_finance_agent
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/ai_personal_finance_agent/finance_agent.py b/ai_agent_tutorials/ai_personal_finance_agent/finance_agent.py
index 55be0a4..4d59936 100644
--- a/ai_agent_tutorials/ai_personal_finance_agent/finance_agent.py
+++ b/ai_agent_tutorials/ai_personal_finance_agent/finance_agent.py
@@ -1,8 +1,8 @@
from textwrap import dedent
-from phi.assistant import Assistant
-from phi.tools.serpapi_tools import SerpApiTools
+from agno.agent import Agent
+from agno.tools.serpapi import SerpApiTools
import streamlit as st
-from phi.llm.openai import OpenAIChat
+from agno.models.openai import OpenAIChat
# Set up the Streamlit app
st.title("AI Personal Finance Planner ๐ฐ")
@@ -15,10 +15,10 @@ openai_api_key = st.text_input("Enter OpenAI API Key to access GPT-4o", type="pa
serp_api_key = st.text_input("Enter Serp API Key for Search functionality", type="password")
if openai_api_key and serp_api_key:
- researcher = Assistant(
+ researcher = Agent(
name="Researcher",
role="Searches for financial advice, investment opportunities, and savings strategies based on user preferences",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a world-class financial researcher. Given a user's financial goals and current financial situation,
@@ -35,10 +35,10 @@ if openai_api_key and serp_api_key:
tools=[SerpApiTools(api_key=serp_api_key)],
add_datetime_to_instructions=True,
)
- planner = Assistant(
+ planner = Agent(
name="Planner",
role="Generates a personalized financial plan based on user preferences and research results",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a senior financial planner. Given a user's financial goals, current financial situation, and a list of research results,
@@ -54,8 +54,6 @@ if openai_api_key and serp_api_key:
"Never make up facts or plagiarize. Always provide proper attribution.",
],
add_datetime_to_instructions=True,
- add_chat_history_to_prompt=True,
- num_history_messages=3,
)
# Input fields for the user's financial goals and current financial situation
@@ -66,4 +64,4 @@ if openai_api_key and serp_api_key:
with st.spinner("Processing..."):
# Get the response from the assistant
response = planner.run(f"Financial goals: {financial_goals}, Current situation: {current_situation}", stream=False)
- st.write(response)
+ st.write(response.content)
diff --git a/ai_agent_tutorials/ai_personal_finance_agent/requirements.txt b/ai_agent_tutorials/ai_personal_finance_agent/requirements.txt
index 549573b..ffff278 100644
--- a/ai_agent_tutorials/ai_personal_finance_agent/requirements.txt
+++ b/ai_agent_tutorials/ai_personal_finance_agent/requirements.txt
@@ -1,4 +1,4 @@
streamlit
-phidata
+agno
openai
google-search-results
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_real_estate_agent/README.md b/ai_agent_tutorials/ai_real_estate_agent/README.md
new file mode 100644
index 0000000..c9e9f44
--- /dev/null
+++ b/ai_agent_tutorials/ai_real_estate_agent/README.md
@@ -0,0 +1,61 @@
+## ๐ AI Real Estate Agent - Powered by Firecrawl's Extract Endpoint
+
+The AI Real Estate Agent automates property search and market analysis using Firecrawl's Extract endpoint and Agno AI Agent's insights. It helps users find properties matching their criteria while providing detailed location trends and investment recommendations. This agent streamlines the property search process by combining data from multiple real estate websites and offering intelligent analysis.
+
+### Features
+- **Smart Property Search**: Uses Firecrawl's Extract endpoint to find properties across multiple real estate websites
+- **Multi-Source Integration**: Aggregates data from 99acres, Housing.com, Square Yards, Nobroker, and MagicBricks
+- **Location Analysis**: Provides detailed price trends and investment insights for different localities
+- **AI-Powered Recommendations**: Uses GPT models to analyze properties and provide structured recommendations
+- **User-Friendly Interface**: Clean Streamlit UI for easy property search and results viewing
+- **Customizable Search**: Filter by city, property type, category, and budget
+
+### How to Get Started
+1. **Clone the repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_real_estate_agent
+ ```
+
+2. **Install the required packages**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+
+3. **Set up your API keys**:
+ - Get your Firecrawl API key from [Firecrawl's website](https://www.firecrawl.dev/app/api-keys)
+ - Get your OpenAI API key from [OpenAI's website](https://platform.openai.com/api-keys)
+
+4. **Run the application**:
+ ```bash
+ streamlit run ai_real_estate_agent.py
+ ```
+
+### Using the Agent
+1. **Enter API Keys**:
+ - Input your Firecrawl and OpenAI API keys in the sidebar
+ - Keys are securely stored in the session state
+
+2. **Set Search Criteria**:
+ - Enter the city name
+ - Select property category (Residential/Commercial)
+ - Choose property type (Flat/Individual House)
+ - Set maximum budget in Crores
+
+3. **View Results**:
+ - Property recommendations with detailed analysis
+ - Location trends with investment insights
+ - Expandable sections for easy reading
+
+### Features in Detail
+- **Property Finding**:
+ - Searches across multiple real estate websites
+ - Returns 3-6 properties matching criteria
+ - Provides detailed property information and analysis
+
+- **Location Analysis**:
+ - Price trends for different localities
+ - Rental yield analysis
+ - Investment potential assessment
+ - Top performing areas identification
+
diff --git a/ai_agent_tutorials/ai_real_estate_agent/ai_real_estate_agent.py b/ai_agent_tutorials/ai_real_estate_agent/ai_real_estate_agent.py
new file mode 100644
index 0000000..f9b65d2
--- /dev/null
+++ b/ai_agent_tutorials/ai_real_estate_agent/ai_real_estate_agent.py
@@ -0,0 +1,321 @@
+from typing import Dict, List
+from pydantic import BaseModel, Field
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+from firecrawl import FirecrawlApp
+import streamlit as st
+
+class PropertyData(BaseModel):
+ """Schema for property data extraction"""
+ building_name: str = Field(description="Name of the building/property", alias="Building_name")
+ property_type: str = Field(description="Type of property (commercial, residential, etc)", alias="Property_type")
+ location_address: str = Field(description="Complete address of the property")
+ price: str = Field(description="Price of the property", alias="Price")
+ description: str = Field(description="Detailed description of the property", alias="Description")
+
+class PropertiesResponse(BaseModel):
+ """Schema for multiple properties response"""
+ properties: List[PropertyData] = Field(description="List of property details")
+
+class LocationData(BaseModel):
+ """Schema for location price trends"""
+ location: str
+ price_per_sqft: float
+ percent_increase: float
+ rental_yield: float
+
+class LocationsResponse(BaseModel):
+ """Schema for multiple locations response"""
+ locations: List[LocationData] = Field(description="List of location data points")
+
+class FirecrawlResponse(BaseModel):
+ """Schema for Firecrawl API response"""
+ success: bool
+ data: Dict
+ status: str
+ expiresAt: str
+
+class PropertyFindingAgent:
+ """Agent responsible for finding properties and providing recommendations"""
+
+ def __init__(self, firecrawl_api_key: str, openai_api_key: str, model_id: str = "o3-mini"):
+ self.agent = Agent(
+ model=OpenAIChat(id=model_id, api_key=openai_api_key),
+ markdown=True,
+ description="I am a real estate expert who helps find and analyze properties based on user preferences."
+ )
+ self.firecrawl = FirecrawlApp(api_key=firecrawl_api_key)
+
+ def find_properties(
+ self,
+ city: str,
+ max_price: float,
+ property_category: str = "Residential",
+ property_type: str = "Flat"
+ ) -> str:
+ """Find and analyze properties based on user preferences"""
+ formatted_location = city.lower()
+
+ urls = [
+ f"https://www.squareyards.com/sale/property-for-sale-in-{formatted_location}/*",
+ f"https://www.99acres.com/property-in-{formatted_location}-ffid/*",
+ f"https://housing.com/in/buy/{formatted_location}/{formatted_location}",
+ # f"https://www.nobroker.in/property/sale/{city}/{formatted_location}",
+ ]
+
+ property_type_prompt = "Flats" if property_type == "Flat" else "Individual Houses"
+
+ raw_response = self.firecrawl.extract(
+ urls=urls,
+ params={
+ 'prompt': f"""Extract ONLY 10 OR LESS different {property_category} {property_type_prompt} from {city} that cost less than {max_price} crores.
+
+ Requirements:
+ - Property Category: {property_category} properties only
+ - Property Type: {property_type_prompt} only
+ - Location: {city}
+ - Maximum Price: {max_price} crores
+ - Include complete property details with exact location
+ - IMPORTANT: Return data for at least 3 different properties. MAXIMUM 10.
+ - Format as a list of properties with their respective details
+ """,
+ 'schema': PropertiesResponse.model_json_schema()
+ }
+ )
+
+ print("Raw Property Response:", raw_response)
+
+ if isinstance(raw_response, dict) and raw_response.get('success'):
+ properties = raw_response['data'].get('properties', [])
+ else:
+ properties = []
+
+ print("Processed Properties:", properties)
+
+
+ analysis = self.agent.run(
+ f"""As a real estate expert, analyze these properties and market trends:
+
+ Properties Found in json format:
+ {properties}
+
+ **IMPORTANT INSTRUCTIONS:**
+ 1. ONLY analyze properties from the above JSON data that match the user's requirements:
+ - Property Category: {property_category}
+ - Property Type: {property_type}
+ - Maximum Price: {max_price} crores
+ 2. DO NOT create new categories or property types
+ 3. From the matching properties, select 5-6 properties with prices closest to {max_price} crores
+
+ Please provide your analysis in this format:
+
+ ๐ SELECTED PROPERTIES
+ โข List only 5-6 best matching properties with prices closest to {max_price} crores
+ โข For each property include:
+ - Name and Location
+ - Price (with value analysis)
+ - Key Features
+ - Pros and Cons
+
+ ๐ฐ BEST VALUE ANALYSIS
+ โข Compare the selected properties based on:
+ - Price per sq ft
+ - Location advantage
+ - Amenities offered
+
+ ๐ LOCATION INSIGHTS
+ โข Specific advantages of the areas where selected properties are located
+
+ ๐ก RECOMMENDATIONS
+ โข Top 3 properties from the selection with reasoning
+ โข Investment potential
+ โข Points to consider before purchase
+
+ ๐ค NEGOTIATION TIPS
+ โข Property-specific negotiation strategies
+
+ Format your response in a clear, structured way using the above sections.
+ """
+ )
+
+ return analysis.content
+
+ def get_location_trends(self, city: str) -> str:
+ """Get price trends for different localities in the city"""
+ raw_response = self.firecrawl.extract([
+ f"https://www.99acres.com/property-rates-and-price-trends-in-{city.lower()}-prffid/*"
+ ], {
+ 'prompt': """Extract price trends data for ALL major localities in the city.
+ IMPORTANT:
+ - Return data for at least 5-10 different localities
+ - Include both premium and affordable areas
+ - Do not skip any locality mentioned in the source
+ - Format as a list of locations with their respective data
+ """,
+ 'schema': LocationsResponse.model_json_schema(),
+ })
+
+ if isinstance(raw_response, dict) and raw_response.get('success'):
+ locations = raw_response['data'].get('locations', [])
+
+ analysis = self.agent.run(
+ f"""As a real estate expert, analyze these location price trends for {city}:
+
+ {locations}
+
+ Please provide:
+ 1. A bullet-point summary of the price trends for each location
+ 2. Identify the top 3 locations with:
+ - Highest price appreciation
+ - Best rental yields
+ - Best value for money
+ 3. Investment recommendations:
+ - Best locations for long-term investment
+ - Best locations for rental income
+ - Areas showing emerging potential
+ 4. Specific advice for investors based on these trends
+
+ Format the response as follows:
+
+ ๐ LOCATION TRENDS SUMMARY
+ โข [Bullet points for each location]
+
+ ๐ TOP PERFORMING AREAS
+ โข [Bullet points for best areas]
+
+ ๐ก INVESTMENT INSIGHTS
+ โข [Bullet points with investment advice]
+
+ ๐ฏ RECOMMENDATIONS
+ โข [Bullet points with specific recommendations]
+ """
+ )
+
+ return analysis.content
+
+ return "No price trends data available"
+
+def create_property_agent():
+ """Create PropertyFindingAgent with API keys from session state"""
+ if 'property_agent' not in st.session_state:
+ st.session_state.property_agent = PropertyFindingAgent(
+ firecrawl_api_key=st.session_state.firecrawl_key,
+ openai_api_key=st.session_state.openai_key,
+ model_id=st.session_state.model_id
+ )
+
+def main():
+ st.set_page_config(
+ page_title="AI Real Estate Agent",
+ page_icon="๐ ",
+ layout="wide"
+ )
+
+ with st.sidebar:
+ st.title("๐ API Configuration")
+
+ st.subheader("๐ค Model Selection")
+ model_id = st.selectbox(
+ "Choose OpenAI Model",
+ options=["o3-mini", "gpt-4o"],
+ help="Select the AI model to use. Choose gpt-4o if your api doesn't have access to o3-mini"
+ )
+ st.session_state.model_id = model_id
+
+ st.divider()
+
+ st.subheader("๐ API Keys")
+ firecrawl_key = st.text_input(
+ "Firecrawl API Key",
+ type="password",
+ help="Enter your Firecrawl API key"
+ )
+ openai_key = st.text_input(
+ "OpenAI API Key",
+ type="password",
+ help="Enter your OpenAI API key"
+ )
+
+ if firecrawl_key and openai_key:
+ st.session_state.firecrawl_key = firecrawl_key
+ st.session_state.openai_key = openai_key
+ create_property_agent()
+
+ st.title("๐ AI Real Estate Agent")
+ st.info(
+ """
+ Welcome to the AI Real Estate Agent!
+ Enter your search criteria below to get property recommendations
+ and location insights.
+ """
+ )
+
+ col1, col2 = st.columns(2)
+
+ with col1:
+ city = st.text_input(
+ "City",
+ placeholder="Enter city name (e.g., Bangalore)",
+ help="Enter the city where you want to search for properties"
+ )
+
+ property_category = st.selectbox(
+ "Property Category",
+ options=["Residential", "Commercial"],
+ help="Select the type of property you're interested in"
+ )
+
+ with col2:
+ max_price = st.number_input(
+ "Maximum Price (in Crores)",
+ min_value=0.1,
+ max_value=100.0,
+ value=5.0,
+ step=0.1,
+ help="Enter your maximum budget in Crores"
+ )
+
+ property_type = st.selectbox(
+ "Property Type",
+ options=["Flat", "Individual House"],
+ help="Select the specific type of property"
+ )
+
+ if st.button("๐ Start Search", use_container_width=True):
+ if 'property_agent' not in st.session_state:
+ st.error("โ ๏ธ Please enter your API keys in the sidebar first!")
+ return
+
+ if not city:
+ st.error("โ ๏ธ Please enter a city name!")
+ return
+
+ try:
+ with st.spinner("๐ Searching for properties..."):
+ property_results = st.session_state.property_agent.find_properties(
+ city=city,
+ max_price=max_price,
+ property_category=property_category,
+ property_type=property_type
+ )
+
+ st.success("โ
Property search completed!")
+
+ st.subheader("๐๏ธ Property Recommendations")
+ st.markdown(property_results)
+
+ st.divider()
+
+ with st.spinner("๐ Analyzing location trends..."):
+ location_trends = st.session_state.property_agent.get_location_trends(city)
+
+ st.success("โ
Location analysis completed!")
+
+ with st.expander("๐ Location Trends Analysis of the city"):
+ st.markdown(location_trends)
+
+ except Exception as e:
+ st.error(f"โ An error occurred: {str(e)}")
+
+if __name__ == "__main__":
+ main()
diff --git a/ai_agent_tutorials/ai_real_estate_agent/requirements.txt b/ai_agent_tutorials/ai_real_estate_agent/requirements.txt
new file mode 100644
index 0000000..8590901
--- /dev/null
+++ b/ai_agent_tutorials/ai_real_estate_agent/requirements.txt
@@ -0,0 +1,5 @@
+agno
+firecrawl-py==1.9.0
+pydantic
+streamlit
+openai
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_reasoning_agent/README.md b/ai_agent_tutorials/ai_reasoning_agent/README.md
new file mode 100644
index 0000000..119bc83
--- /dev/null
+++ b/ai_agent_tutorials/ai_reasoning_agent/README.md
@@ -0,0 +1,51 @@
+## AI Reasoning Agent
+
+The AI Reasoning Agent leverages advanced AI models to provide insightful reasoning and decision-making capabilities. This agent is designed to assist users in various analytical tasks by processing information and generating structured outputs.
+
+### Features
+- **Advanced Reasoning**: Utilizes the Ollama model to perform complex reasoning tasks
+- **Interactive Playground**: Provides a user-friendly interface for interacting with the reasoning agent
+- **Markdown Support**: Outputs results in markdown format for easy readability and sharing
+- **Customizable Agent**: Easily configurable to suit different reasoning scenarios
+
+### How to Get Started
+1. **Clone the repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_reasoning_agent
+ ```
+
+2. **Install the required packages**:
+ #### For Local AI Reasoning Agent
+ ```bash
+ pip install -r requirements_local_ai_reasoning_agent.txt
+ ```
+
+3. **Run the application**:
+ ```bash
+ python local_ai_reasoning_agent.py
+ ```
+
+### Using the Agent
+1. **Access the Playground**:
+ - Open the provided URL to access the interactive playground
+ - The playground allows you to input queries and receive structured reasoning outputs
+
+2. **Input Queries**:
+ - Enter your queries in the provided input field
+ - The agent processes the input and provides detailed reasoning and analysis
+
+3. **View Results**:
+ - Results are displayed in markdown format
+ - Easily copy and share the outputs for further use
+
+### Features in Detail
+- **Reasoning Capabilities**:
+ - Handles a wide range of analytical tasks
+ - Provides clear and structured outputs
+ - Supports markdown for easy sharing and readability
+
+- **Interactive Interface**:
+ - User-friendly playground for seamless interaction
+ - Real-time processing and output generation
+ - Configurable settings to tailor the agent's behavior
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_reasoning_agent/agents.db b/ai_agent_tutorials/ai_reasoning_agent/agents.db
deleted file mode 100644
index c2d3d52..0000000
Binary files a/ai_agent_tutorials/ai_reasoning_agent/agents.db and /dev/null differ
diff --git a/ai_agent_tutorials/ai_reasoning_agent/local_ai_reasoning_agent.py b/ai_agent_tutorials/ai_reasoning_agent/local_ai_reasoning_agent.py
new file mode 100644
index 0000000..d31910c
--- /dev/null
+++ b/ai_agent_tutorials/ai_reasoning_agent/local_ai_reasoning_agent.py
@@ -0,0 +1,12 @@
+from agno.agent import Agent
+from agno.models.ollama import Ollama
+from agno.playground import Playground, serve_playground_app
+
+reasoning_agent = Agent(name="Reasoning Agent", model=Ollama(id="qwq:32b"), markdown=True)
+
+# UI for Reasoning agent
+app = Playground(agents=[reasoning_agent]).get_app()
+
+# Run the Playground app
+if __name__ == "__main__":
+ serve_playground_app("local_ai_reasoning_agent:app", reload=True)
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_reasoning_agent/reasoning_agent.py b/ai_agent_tutorials/ai_reasoning_agent/reasoning_agent.py
index 4f55d79..137b5d3 100644
--- a/ai_agent_tutorials/ai_reasoning_agent/reasoning_agent.py
+++ b/ai_agent_tutorials/ai_reasoning_agent/reasoning_agent.py
@@ -1,9 +1,9 @@
-from phi.agent import Agent
-from phi.model.openai import OpenAIChat
-from phi.cli.console import console
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+from rich.console import Console
regular_agent = Agent(model=OpenAIChat(id="gpt-4o-mini"), markdown=True)
-
+console = Console()
reasoning_agent = Agent(
model=OpenAIChat(id="gpt-4o"),
reasoning=True,
diff --git a/ai_agent_tutorials/ai_reasoning_agent/requirements.txt b/ai_agent_tutorials/ai_reasoning_agent/requirements.txt
new file mode 100644
index 0000000..88c5c83
--- /dev/null
+++ b/ai_agent_tutorials/ai_reasoning_agent/requirements.txt
@@ -0,0 +1,4 @@
+agno
+ollama
+fastapi
+uvicorn
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_recruitment_agent_team/README.md b/ai_agent_tutorials/ai_recruitment_agent_team/README.md
new file mode 100644
index 0000000..55c48dd
--- /dev/null
+++ b/ai_agent_tutorials/ai_recruitment_agent_team/README.md
@@ -0,0 +1,101 @@
+# ๐ผ AI Recruitment Agent Team
+
+A Streamlit application that simulates a full-service recruitment team using multiple AI agents to automate and streamline the hiring process. Each agent represents a different recruitment specialist role - from resume analysis and candidate evaluation to interview scheduling and communication - working together to provide comprehensive hiring solutions. The system combines the expertise of technical recruiters, HR coordinators, and scheduling specialists into a cohesive automated workflow.
+
+## Features
+
+#### Specialized AI Agents
+
+- Technical Recruiter Agent: Analyzes resumes and evaluates technical skills
+- Communication Agent: Handles professional email correspondence
+- Scheduling Coordinator Agent: Manages interview scheduling and coordination
+- Each agent has specific expertise and collaborates for comprehensive recruitment
+
+
+#### End-to-End Recruitment Process
+- Automated resume screening and analysis
+- Role-specific technical evaluation
+- Professional candidate communication
+- Automated interview scheduling
+- Integrated feedback system
+
+## Important Things to do before running the application
+
+- Create/Use a new Gmail account for the recruiter
+- Enable 2-Step Verification and generate an App Password for the Gmail account
+- The App Password is a 16 digit code (use without spaces) that should be generated here - [Google App Password](https://support.google.com/accounts/answer/185833?hl=en) Please go through the steps to generate the password - it will of the format - 'afec wejf awoj fwrv' (remove the spaces and enter it in the streamlit app)
+- Create/ Use a Zoom account and go to the Zoom App Marketplace to get the API credentials :
+[Zoom Marketplace](https://marketplace.zoom.us)
+- Go to Developer Dashboard and create a new app - Select Server to Server OAuth and get the credentials, You see 3 credentials - Client ID, Client Secret and Account ID
+- After that, you need to add a few scopes to the app - so that the zoom link of the candidate is sent and created through the mail.
+- The Scopes are meeting:write:invite_links:admin, meeting:write:meeting:admin, meeting:write:meeting:master, meeting:write:invite_links:master, meeting:write:open_app:admin, user:read:email:admin, user:read:list_users:admin, billing:read:user_entitlement:admin, dashboard:read:list_meeting_participants:admin [last 3 are optional]
+
+## How to Run
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_recruitment_agent_team
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+2. **Configure API Keys**
+ - OpenAI API key for GPT-4o access
+ - Zoom API credentials (Account ID, Client ID, Client Secret)
+ - Email App Password of Recruiter's Email
+
+3. **Run the Application**
+ ```bash
+ streamlit run ai_recruitment_agent_team.py
+ ```
+
+## System Components
+
+- **Resume Analyzer Agent**
+ - Skills matching algorithm
+ - Experience verification
+ - Technical assessment
+ - Selection decision making
+
+- **Email Communication Agent**
+ - Professional email drafting
+ - Automated notifications
+ - Feedback communication
+ - Follow-up management
+
+- **Interview Scheduler Agent**
+ - Zoom meeting coordination
+ - Calendar management
+ - Timezone handling
+ - Reminder system
+
+- **Candidate Experience**
+ - Simple upload interface
+ - Real-time feedback
+ - Clear communication
+ - Streamlined process
+
+## Technical Stack
+
+- **Framework**: Phidata
+- **Model**: OpenAI GPT-4o
+- **Integration**: Zoom API, EmailTools Tool from Phidata
+- **PDF Processing**: PyPDF2
+- **Time Management**: pytz
+- **State Management**: Streamlit Session State
+
+
+## Disclaimer
+
+This tool is designed to assist in the recruitment process but should not completely replace human judgment in hiring decisions. All automated decisions should be reviewed by human recruiters for final approval.
+
+## Future Enhancements
+
+- Integration with ATS systems
+- Advanced candidate scoring
+- Video interview capabilities
+- Skills assessment integration
+- Multi-language support
diff --git a/ai_agent_tutorials/ai_recruitment_agent_team/ai_recruitment_agent_team.py b/ai_agent_tutorials/ai_recruitment_agent_team/ai_recruitment_agent_team.py
new file mode 100644
index 0000000..59e56dc
--- /dev/null
+++ b/ai_agent_tutorials/ai_recruitment_agent_team/ai_recruitment_agent_team.py
@@ -0,0 +1,521 @@
+from typing import Literal, Tuple, Dict, Optional
+import os
+import time
+import json
+import requests
+import PyPDF2
+from datetime import datetime, timedelta
+import pytz
+
+import streamlit as st
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+from agno.tools.email import EmailTools
+from phi.tools.zoom import ZoomTool
+from phi.utils.log import logger
+from streamlit_pdf_viewer import pdf_viewer
+
+
+
+class CustomZoomTool(ZoomTool):
+ def __init__(self, *, account_id: Optional[str] = None, client_id: Optional[str] = None, client_secret: Optional[str] = None, name: str = "zoom_tool"):
+ super().__init__(account_id=account_id, client_id=client_id, client_secret=client_secret, name=name)
+ self.token_url = "https://zoom.us/oauth/token"
+ self.access_token = None
+ self.token_expires_at = 0
+
+ def get_access_token(self) -> str:
+ if self.access_token and time.time() < self.token_expires_at:
+ return str(self.access_token)
+
+ headers = {"Content-Type": "application/x-www-form-urlencoded"}
+ data = {"grant_type": "account_credentials", "account_id": self.account_id}
+
+ try:
+ response = requests.post(self.token_url, headers=headers, data=data, auth=(self.client_id, self.client_secret))
+ response.raise_for_status()
+
+ token_info = response.json()
+ self.access_token = token_info["access_token"]
+ expires_in = token_info["expires_in"]
+ self.token_expires_at = time.time() + expires_in - 60
+
+ self._set_parent_token(str(self.access_token))
+ return str(self.access_token)
+
+ except requests.RequestException as e:
+ logger.error(f"Error fetching access token: {e}")
+ return ""
+
+ def _set_parent_token(self, token: str) -> None:
+ """Helper method to set the token in the parent ZoomTool class"""
+ if token:
+ self._ZoomTool__access_token = token
+
+
+# Role requirements as a constant dictionary
+ROLE_REQUIREMENTS: Dict[str, str] = {
+ "ai_ml_engineer": """
+ Required Skills:
+ - Python, PyTorch/TensorFlow
+ - Machine Learning algorithms and frameworks
+ - Deep Learning and Neural Networks
+ - Data preprocessing and analysis
+ - MLOps and model deployment
+ - RAG, LLM, Finetuning and Prompt Engineering
+ """,
+
+ "frontend_engineer": """
+ Required Skills:
+ - React/Vue.js/Angular
+ - HTML5, CSS3, JavaScript/TypeScript
+ - Responsive design
+ - State management
+ - Frontend testing
+ """,
+
+ "backend_engineer": """
+ Required Skills:
+ - Python/Java/Node.js
+ - REST APIs
+ - Database design and management
+ - System architecture
+ - Cloud services (AWS/GCP/Azure)
+ - Kubernetes, Docker, CI/CD
+ """
+}
+
+
+def init_session_state() -> None:
+ """Initialize only necessary session state variables."""
+ defaults = {
+ 'candidate_email': "", 'openai_api_key': "", 'resume_text': "", 'analysis_complete': False,
+ 'is_selected': False, 'zoom_account_id': "", 'zoom_client_id': "", 'zoom_client_secret': "",
+ 'email_sender': "", 'email_passkey': "", 'company_name': "", 'current_pdf': None
+ }
+ for key, value in defaults.items():
+ if key not in st.session_state:
+ st.session_state[key] = value
+
+
+def create_resume_analyzer() -> Agent:
+ """Creates and returns a resume analysis agent."""
+ if not st.session_state.openai_api_key:
+ st.error("Please enter your OpenAI API key first.")
+ return None
+
+ return Agent(
+ model=OpenAIChat(
+ id="gpt-4o",
+ api_key=st.session_state.openai_api_key
+ ),
+ description="You are an expert technical recruiter who analyzes resumes.",
+ instructions=[
+ "Analyze the resume against the provided job requirements",
+ "Be lenient with AI/ML candidates who show strong potential",
+ "Consider project experience as valid experience",
+ "Value hands-on experience with key technologies",
+ "Return a JSON response with selection decision and feedback"
+ ],
+ markdown=True
+ )
+
+def create_email_agent() -> Agent:
+ return Agent(
+ model=OpenAIChat(
+ id="gpt-4o",
+ api_key=st.session_state.openai_api_key
+ ),
+ tools=[EmailTools(
+ receiver_email=st.session_state.candidate_email,
+ sender_email=st.session_state.email_sender,
+ sender_name=st.session_state.company_name,
+ sender_passkey=st.session_state.email_passkey
+ )],
+ description="You are a professional recruitment coordinator handling email communications.",
+ instructions=[
+ "Draft and send professional recruitment emails",
+ "Act like a human writing an email and use all lowercase letters",
+ "Maintain a friendly yet professional tone",
+ "Always end emails with exactly: 'best,\nthe ai recruiting team'",
+ "Never include the sender's or receiver's name in the signature",
+ f"The name of the company is '{st.session_state.company_name}'"
+ ],
+ markdown=True,
+ show_tool_calls=True
+ )
+
+
+def create_scheduler_agent() -> Agent:
+ zoom_tools = CustomZoomTool(
+ account_id=st.session_state.zoom_account_id,
+ client_id=st.session_state.zoom_client_id,
+ client_secret=st.session_state.zoom_client_secret
+ )
+
+ return Agent(
+ name="Interview Scheduler",
+ model=OpenAIChat(
+ id="gpt-4o",
+ api_key=st.session_state.openai_api_key
+ ),
+ tools=[zoom_tools],
+ description="You are an interview scheduling coordinator.",
+ instructions=[
+ "You are an expert at scheduling technical interviews using Zoom.",
+ "Schedule interviews during business hours (9 AM - 5 PM EST)",
+ "Create meetings with proper titles and descriptions",
+ "Ensure all meeting details are included in responses",
+ "Use ISO 8601 format for dates",
+ "Handle scheduling errors gracefully"
+ ],
+ markdown=True,
+ show_tool_calls=True
+ )
+
+
+def extract_text_from_pdf(pdf_file) -> str:
+ try:
+ pdf_reader = PyPDF2.PdfReader(pdf_file)
+ text = ""
+ for page in pdf_reader.pages:
+ text += page.extract_text()
+ return text
+ except Exception as e:
+ st.error(f"Error extracting PDF text: {str(e)}")
+ return ""
+
+
+def analyze_resume(
+ resume_text: str,
+ role: Literal["ai_ml_engineer", "frontend_engineer", "backend_engineer"],
+ analyzer: Agent
+) -> Tuple[bool, str]:
+ try:
+ response = analyzer.run(
+ f"""Please analyze this resume against the following requirements and provide your response in valid JSON format:
+ Role Requirements:
+ {ROLE_REQUIREMENTS[role]}
+ Resume Text:
+ {resume_text}
+ Your response must be a valid JSON object like this:
+ {{
+ "selected": true/false,
+ "feedback": "Detailed feedback explaining the decision",
+ "matching_skills": ["skill1", "skill2"],
+ "missing_skills": ["skill3", "skill4"],
+ "experience_level": "junior/mid/senior"
+ }}
+ Evaluation criteria:
+ 1. Match at least 70% of required skills
+ 2. Consider both theoretical knowledge and practical experience
+ 3. Value project experience and real-world applications
+ 4. Consider transferable skills from similar technologies
+ 5. Look for evidence of continuous learning and adaptability
+ Important: Return ONLY the JSON object without any markdown formatting or backticks.
+ """
+ )
+
+ assistant_message = next((msg.content for msg in response.messages if msg.role == 'assistant'), None)
+ if not assistant_message:
+ raise ValueError("No assistant message found in response.")
+
+ result = json.loads(assistant_message.strip())
+ if not isinstance(result, dict) or not all(k in result for k in ["selected", "feedback"]):
+ raise ValueError("Invalid response format")
+
+ return result["selected"], result["feedback"]
+
+ except (json.JSONDecodeError, ValueError) as e:
+ st.error(f"Error processing response: {str(e)}")
+ return False, f"Error analyzing resume: {str(e)}"
+
+
+def send_selection_email(email_agent: Agent, to_email: str, role: str) -> None:
+ email_agent.run(
+ f"""
+ Send an email to {to_email} regarding their selection for the {role} position.
+ The email should:
+ 1. Congratulate them on being selected
+ 2. Explain the next steps in the process
+ 3. Mention that they will receive interview details shortly
+ 4. The name of the company is 'AI Recruiting Team'
+ """
+ )
+
+
+def send_rejection_email(email_agent: Agent, to_email: str, role: str, feedback: str) -> None:
+ """
+ Send a rejection email with constructive feedback.
+ """
+ email_agent.run(
+ f"""
+ Send an email to {to_email} regarding their application for the {role} position.
+ Use this specific style:
+ 1. use all lowercase letters
+ 2. be empathetic and human
+ 3. mention specific feedback from: {feedback}
+ 4. encourage them to upskill and try again
+ 5. suggest some learning resources based on missing skills
+ 6. end the email with exactly:
+ best,
+ the ai recruiting team
+
+ Do not include any names in the signature.
+ The tone should be like a human writing a quick but thoughtful email.
+ """
+ )
+
+
+def schedule_interview(scheduler: Agent, candidate_email: str, email_agent: Agent, role: str) -> None:
+ """
+ Schedule interviews during business hours (9 AM - 5 PM IST).
+ """
+ try:
+ # Get current time in IST
+ ist_tz = pytz.timezone('Asia/Kolkata')
+ current_time_ist = datetime.now(ist_tz)
+
+ tomorrow_ist = current_time_ist + timedelta(days=1)
+ interview_time = tomorrow_ist.replace(hour=11, minute=0, second=0, microsecond=0)
+ formatted_time = interview_time.strftime('%Y-%m-%dT%H:%M:%S')
+
+ meeting_response = scheduler.run(
+ f"""Schedule a 60-minute technical interview with these specifications:
+ - Title: '{role} Technical Interview'
+ - Date: {formatted_time}
+ - Timezone: IST (India Standard Time)
+ - Attendee: {candidate_email}
+
+ Important Notes:
+ - The meeting must be between 9 AM - 5 PM IST
+ - Use IST (UTC+5:30) timezone for all communications
+ - Include timezone information in the meeting details
+ """
+ )
+
+ email_agent.run(
+ f"""Send an interview confirmation email with these details:
+ - Role: {role} position
+ - Meeting Details: {meeting_response}
+
+ Important:
+ - Clearly specify that the time is in IST (India Standard Time)
+ - Ask the candidate to join 5 minutes early
+ - Include timezone conversion link if possible
+ - Ask him to be confident and not so nervous and prepare well for the interview
+ """
+ )
+
+ st.success("Interview scheduled successfully! Check your email for details.")
+
+ except Exception as e:
+ logger.error(f"Error scheduling interview: {str(e)}")
+ st.error("Unable to schedule interview. Please try again.")
+
+
+def main() -> None:
+ st.title("AI Recruitment System")
+
+ init_session_state()
+ with st.sidebar:
+ st.header("Configuration")
+
+ # OpenAI Configuration
+ st.subheader("OpenAI Settings")
+ api_key = st.text_input("OpenAI API Key", type="password", value=st.session_state.openai_api_key, help="Get your API key from platform.openai.com")
+ if api_key: st.session_state.openai_api_key = api_key
+
+ st.subheader("Zoom Settings")
+ zoom_account_id = st.text_input("Zoom Account ID", type="password", value=st.session_state.zoom_account_id)
+ zoom_client_id = st.text_input("Zoom Client ID", type="password", value=st.session_state.zoom_client_id)
+ zoom_client_secret = st.text_input("Zoom Client Secret", type="password", value=st.session_state.zoom_client_secret)
+
+ st.subheader("Email Settings")
+ email_sender = st.text_input("Sender Email", value=st.session_state.email_sender, help="Email address to send from")
+ email_passkey = st.text_input("Email App Password", type="password", value=st.session_state.email_passkey, help="App-specific password for email")
+ company_name = st.text_input("Company Name", value=st.session_state.company_name, help="Name to use in email communications")
+
+ if zoom_account_id: st.session_state.zoom_account_id = zoom_account_id
+ if zoom_client_id: st.session_state.zoom_client_id = zoom_client_id
+ if zoom_client_secret: st.session_state.zoom_client_secret = zoom_client_secret
+ if email_sender: st.session_state.email_sender = email_sender
+ if email_passkey: st.session_state.email_passkey = email_passkey
+ if company_name: st.session_state.company_name = company_name
+
+ required_configs = {'OpenAI API Key': st.session_state.openai_api_key, 'Zoom Account ID': st.session_state.zoom_account_id,
+ 'Zoom Client ID': st.session_state.zoom_client_id, 'Zoom Client Secret': st.session_state.zoom_client_secret,
+ 'Email Sender': st.session_state.email_sender, 'Email Password': st.session_state.email_passkey,
+ 'Company Name': st.session_state.company_name}
+
+ missing_configs = [k for k, v in required_configs.items() if not v]
+ if missing_configs:
+ st.warning(f"Please configure the following in the sidebar: {', '.join(missing_configs)}")
+ return
+
+ if not st.session_state.openai_api_key:
+ st.warning("Please enter your OpenAI API key in the sidebar to continue.")
+ return
+
+ role = st.selectbox("Select the role you're applying for:", ["ai_ml_engineer", "frontend_engineer", "backend_engineer"])
+ with st.expander("View Required Skills", expanded=True): st.markdown(ROLE_REQUIREMENTS[role])
+
+ # Add a "New Application" button before the resume upload
+ if st.button("๐ New Application"):
+ # Clear only the application-related states
+ keys_to_clear = ['resume_text', 'analysis_complete', 'is_selected', 'candidate_email', 'current_pdf']
+ for key in keys_to_clear:
+ if key in st.session_state:
+ st.session_state[key] = None if key == 'current_pdf' else ""
+ st.rerun()
+
+ resume_file = st.file_uploader("Upload your resume (PDF)", type=["pdf"], key="resume_uploader")
+ if resume_file is not None and resume_file != st.session_state.get('current_pdf'):
+ st.session_state.current_pdf = resume_file
+ st.session_state.resume_text = ""
+ st.session_state.analysis_complete = False
+ st.session_state.is_selected = False
+ st.rerun()
+
+ if resume_file:
+ st.subheader("Uploaded Resume")
+ col1, col2 = st.columns([4, 1])
+
+ with col1:
+ import tempfile, os
+ with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
+ tmp_file.write(resume_file.read())
+ tmp_file_path = tmp_file.name
+ resume_file.seek(0)
+ try: pdf_viewer(tmp_file_path)
+ finally: os.unlink(tmp_file_path)
+
+ with col2:
+ st.download_button(label="๐ฅ Download", data=resume_file, file_name=resume_file.name, mime="application/pdf")
+ # Process the resume text
+ if not st.session_state.resume_text:
+ with st.spinner("Processing your resume..."):
+ resume_text = extract_text_from_pdf(resume_file)
+ if resume_text:
+ st.session_state.resume_text = resume_text
+ st.success("Resume processed successfully!")
+ else:
+ st.error("Could not process the PDF. Please try again.")
+
+ # Email input with session state
+ email = st.text_input(
+ "Candidate's email address",
+ value=st.session_state.candidate_email,
+ key="email_input"
+ )
+ st.session_state.candidate_email = email
+
+ # Analysis and next steps
+ if st.session_state.resume_text and email and not st.session_state.analysis_complete:
+ if st.button("Analyze Resume"):
+ with st.spinner("Analyzing your resume..."):
+ resume_analyzer = create_resume_analyzer()
+ email_agent = create_email_agent() # Create email agent here
+
+ if resume_analyzer and email_agent:
+ print("DEBUG: Starting resume analysis")
+ is_selected, feedback = analyze_resume(
+ st.session_state.resume_text,
+ role,
+ resume_analyzer
+ )
+ print(f"DEBUG: Analysis complete - Selected: {is_selected}, Feedback: {feedback}")
+
+ if is_selected:
+ st.success("Congratulations! Your skills match our requirements.")
+ st.session_state.analysis_complete = True
+ st.session_state.is_selected = True
+ st.rerun()
+ else:
+ st.warning("Unfortunately, your skills don't match our requirements.")
+ st.write(f"Feedback: {feedback}")
+
+ # Send rejection email
+ with st.spinner("Sending feedback email..."):
+ try:
+ send_rejection_email(
+ email_agent=email_agent,
+ to_email=email,
+ role=role,
+ feedback=feedback
+ )
+ st.info("We've sent you an email with detailed feedback.")
+ except Exception as e:
+ logger.error(f"Error sending rejection email: {e}")
+ st.error("Could not send feedback email. Please try again.")
+
+ if st.session_state.get('analysis_complete') and st.session_state.get('is_selected', False):
+ st.success("Congratulations! Your skills match our requirements.")
+ st.info("Click 'Proceed with Application' to continue with the interview process.")
+
+ if st.button("Proceed with Application", key="proceed_button"):
+ print("DEBUG: Proceed button clicked") # Debug
+ with st.spinner("๐ Processing your application..."):
+ try:
+ print("DEBUG: Creating email agent") # Debug
+ email_agent = create_email_agent()
+ print(f"DEBUG: Email agent created: {email_agent}") # Debug
+
+ print("DEBUG: Creating scheduler agent") # Debug
+ scheduler_agent = create_scheduler_agent()
+ print(f"DEBUG: Scheduler agent created: {scheduler_agent}") # Debug
+
+ # 3. Send selection email
+ with st.status("๐ง Sending confirmation email...", expanded=True) as status:
+ print(f"DEBUG: Attempting to send email to {st.session_state.candidate_email}") # Debug
+ send_selection_email(
+ email_agent,
+ st.session_state.candidate_email,
+ role
+ )
+ print("DEBUG: Email sent successfully") # Debug
+ status.update(label="โ
Confirmation email sent!")
+
+ # 4. Schedule interview
+ with st.status("๐
Scheduling interview...", expanded=True) as status:
+ print("DEBUG: Attempting to schedule interview") # Debug
+ schedule_interview(
+ scheduler_agent,
+ st.session_state.candidate_email,
+ email_agent,
+ role
+ )
+ print("DEBUG: Interview scheduled successfully") # Debug
+ status.update(label="โ
Interview scheduled!")
+
+ print("DEBUG: All processes completed successfully") # Debug
+ st.success("""
+ ๐ Application Successfully Processed!
+
+ Please check your email for:
+ 1. Selection confirmation โ
+ 2. Interview details with Zoom link ๐
+
+ Next steps:
+ 1. Review the role requirements
+ 2. Prepare for your technical interview
+ 3. Join the interview 5 minutes early
+ """)
+
+ except Exception as e:
+ print(f"DEBUG: Error occurred: {str(e)}") # Debug
+ print(f"DEBUG: Error type: {type(e)}") # Debug
+ import traceback
+ print(f"DEBUG: Full traceback: {traceback.format_exc()}") # Debug
+ st.error(f"An error occurred: {str(e)}")
+ st.error("Please try again or contact support.")
+
+ # Reset button
+ if st.sidebar.button("Reset Application"):
+ for key in st.session_state.keys():
+ if key != 'openai_api_key':
+ del st.session_state[key]
+ st.rerun()
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_recruitment_agent_team/requirements.txt b/ai_agent_tutorials/ai_recruitment_agent_team/requirements.txt
new file mode 100644
index 0000000..caaaa4e
--- /dev/null
+++ b/ai_agent_tutorials/ai_recruitment_agent_team/requirements.txt
@@ -0,0 +1,13 @@
+# Core dependencies
+phidata
+agno
+streamlit==1.40.2
+PyPDF2==3.0.1
+streamlit-pdf-viewer==0.0.19
+requests==2.32.3
+pytz==2023.4
+typing-extensions>=4.9.0
+
+# Optional but recommended
+black>=24.1.1 # for code formatting
+python-dateutil>=2.8.2 # for date parsing
diff --git a/ai_agent_tutorials/ai_services_agency/README.md b/ai_agent_tutorials/ai_services_agency/README.md
new file mode 100644
index 0000000..4003cea
--- /dev/null
+++ b/ai_agent_tutorials/ai_services_agency/README.md
@@ -0,0 +1,80 @@
+# AI Services Agency ๐จโ๐ผ
+
+An AI application that simulates a full-service digital agency using multiple AI agents to analyze and plan software projects. Each agent represents a different role in the project lifecycle, from strategic planning to technical implementation.
+
+## Demo:
+
+https://github.com/user-attachments/assets/a0befa3a-f4c3-400d-9790-4b9e37254405
+
+## Features
+
+### Five specialized AI agents
+
+- **CEO Agent**: Strategic leader and final decision maker
+ - Analyzes startup ideas using structured evaluation
+ - Makes strategic decisions across product, technical, marketing, and financial domains
+ - Uses AnalyzeStartupTool and MakeStrategicDecision tools
+
+- **CTO Agent**: Technical architecture and feasibility expert
+ - Evaluates technical requirements and feasibility
+ - Provides architecture decisions
+ - Uses QueryTechnicalRequirements and EvaluateTechnicalFeasibility tools
+
+- **Product Manager Agent**: Product strategy specialist
+ - Defines product strategy and roadmap
+ - Coordinates between technical and marketing teams
+ - Focuses on product-market fit
+
+- **Developer Agent**: Technical implementation expert
+ - Provides detailed technical implementation guidance
+ - Suggests optimal tech stack and cloud solutions
+ - Estimates development costs and timelines
+
+- **Client Success Agent**: Marketing strategy leader
+ - Develops go-to-market strategies
+ - Plans customer acquisition approaches
+ - Coordinates with product team
+
+### Custom Tools
+
+The agency uses specialized tools built with OpenAI Schema for structured analysis:
+- **Analysis Tools**: AnalyzeProjectRequirements for market evaluation and analysis of startup idea
+- **Technical Tools**: CreateTechnicalSpecification for technical assessment
+
+### ๐ Asynchronous Communication
+
+The agency operates in async mode, enabling:
+- Parallel processing of analyses from different agents
+- Efficient multi-agent collaboration
+- Real-time communication between agents
+- Non-blocking operations for better performance
+
+### ๐ Agent Communication Flows
+- CEO โ๏ธ All Agents (Strategic Oversight)
+- CTO โ๏ธ Developer (Technical Implementation)
+- Product Manager โ๏ธ Marketing Manager (Go-to-Market Strategy)
+- Product Manager โ๏ธ Developer (Feature Implementation)
+- (and more!)
+
+## How to Run
+
+Follow the steps below to set up and run the application:
+Before anything else, Please get your OpenAI API Key here: https://platform.openai.com/api-keys
+
+1. **Clone the Repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd awesome-llm-apps/ai_agent_tutorials/ai_services_agency
+ ```
+
+2. **Install the dependencies**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+
+3. **Run the Streamlit app**:
+ ```bash
+ streamlit run ai_services_agency/agency.py
+ ```
+
+4. **Enter your OpenAI API Key** in the sidebar when prompted and start analyzing your startup idea!
diff --git a/ai_agent_tutorials/ai_services_agency/agency.py b/ai_agent_tutorials/ai_services_agency/agency.py
new file mode 100644
index 0000000..43ab885
--- /dev/null
+++ b/ai_agent_tutorials/ai_services_agency/agency.py
@@ -0,0 +1,365 @@
+from typing import List, Literal, Dict, Optional
+from agency_swarm import Agent, Agency, set_openai_key, BaseTool
+from pydantic import Field, BaseModel
+import streamlit as st
+
+class AnalyzeProjectRequirements(BaseTool):
+ project_name: str = Field(..., description="Name of the project")
+ project_description: str = Field(..., description="Project description and goals")
+ project_type: Literal["Web Application", "Mobile App", "API Development",
+ "Data Analytics", "AI/ML Solution", "Other"] = Field(...,
+ description="Type of project")
+ budget_range: Literal["$10k-$25k", "$25k-$50k", "$50k-$100k", "$100k+"] = Field(...,
+ description="Budget range for the project")
+
+ class ToolConfig:
+ name = "analyze_project"
+ description = "Analyzes project requirements and feasibility"
+ one_call_at_a_time = True
+
+ def run(self) -> str:
+ """Analyzes project and stores results in shared state"""
+ if self._shared_state.get("project_analysis", None) is not None:
+ raise ValueError("Project analysis already exists. Please proceed with technical specification.")
+
+ analysis = {
+ "name": self.project_name,
+ "type": self.project_type,
+ "complexity": "high",
+ "timeline": "6 months",
+ "budget_feasibility": "within range",
+ "requirements": ["Scalable architecture", "Security", "API integration"]
+ }
+
+ self._shared_state.set("project_analysis", analysis)
+ return "Project analysis completed. Please proceed with technical specification."
+
+class CreateTechnicalSpecification(BaseTool):
+ architecture_type: Literal["monolithic", "microservices", "serverless", "hybrid"] = Field(
+ ...,
+ description="Proposed architecture type"
+ )
+ core_technologies: str = Field(
+ ...,
+ description="Comma-separated list of main technologies and frameworks"
+ )
+ scalability_requirements: Literal["high", "medium", "low"] = Field(
+ ...,
+ description="Scalability needs"
+ )
+
+ class ToolConfig:
+ name = "create_technical_spec"
+ description = "Creates technical specifications based on project analysis"
+ one_call_at_a_time = True
+
+ def run(self) -> str:
+ """Creates technical specification based on analysis"""
+ project_analysis = self._shared_state.get("project_analysis", None)
+ if project_analysis is None:
+ raise ValueError("Please analyze project requirements first using AnalyzeProjectRequirements tool.")
+
+ spec = {
+ "project_name": project_analysis["name"],
+ "architecture": self.architecture_type,
+ "technologies": self.core_technologies.split(","),
+ "scalability": self.scalability_requirements
+ }
+
+ self._shared_state.set("technical_specification", spec)
+ return f"Technical specification created for {project_analysis['name']}."
+
+def init_session_state() -> None:
+ """Initialize session state variables"""
+ if 'messages' not in st.session_state:
+ st.session_state.messages = []
+ if 'api_key' not in st.session_state:
+ st.session_state.api_key = None
+
+def main() -> None:
+ st.set_page_config(page_title="AI Services Agency", layout="wide")
+ init_session_state()
+
+ st.title("๐ AI Services Agency")
+
+ # API Configuration
+ with st.sidebar:
+ st.header("๐ API Configuration")
+ openai_api_key = st.text_input(
+ "OpenAI API Key",
+ type="password",
+ help="Enter your OpenAI API key to continue"
+ )
+
+ if openai_api_key:
+ st.session_state.api_key = openai_api_key
+ st.success("API Key accepted!")
+ else:
+ st.warning("โ ๏ธ Please enter your OpenAI API Key to proceed")
+ st.markdown("[Get your API key here](https://platform.openai.com/api-keys)")
+ return
+
+ # Initialize agents with the provided API key
+ set_openai_key(st.session_state.api_key)
+ api_headers = {"Authorization": f"Bearer {st.session_state.api_key}"}
+
+ # Project Input Form
+ with st.form("project_form"):
+ st.subheader("Project Details")
+
+ project_name = st.text_input("Project Name")
+ project_description = st.text_area(
+ "Project Description",
+ help="Describe the project, its goals, and any specific requirements"
+ )
+
+ col1, col2 = st.columns(2)
+ with col1:
+ project_type = st.selectbox(
+ "Project Type",
+ ["Web Application", "Mobile App", "API Development",
+ "Data Analytics", "AI/ML Solution", "Other"]
+ )
+ timeline = st.selectbox(
+ "Expected Timeline",
+ ["1-2 months", "3-4 months", "5-6 months", "6+ months"]
+ )
+
+ with col2:
+ budget_range = st.selectbox(
+ "Budget Range",
+ ["$10k-$25k", "$25k-$50k", "$50k-$100k", "$100k+"]
+ )
+ priority = st.selectbox(
+ "Project Priority",
+ ["High", "Medium", "Low"]
+ )
+
+ tech_requirements = st.text_area(
+ "Technical Requirements (optional)",
+ help="Any specific technical requirements or preferences"
+ )
+
+ special_considerations = st.text_area(
+ "Special Considerations (optional)",
+ help="Any additional information or special requirements"
+ )
+
+ submitted = st.form_submit_button("Analyze Project")
+
+ if submitted and project_name and project_description:
+ try:
+ # Set OpenAI key
+ set_openai_key(st.session_state.api_key)
+
+ # Create agents
+ ceo = Agent(
+ name="Project Director",
+ description="You are a CEO of multiple companies in the past and have a lot of experience in evaluating projects and making strategic decisions.",
+ instructions="""
+ You are an experienced CEO who evaluates projects. Follow these steps strictly:
+
+ 1. FIRST, use the AnalyzeProjectRequirements tool with:
+ - project_name: The name from the project details
+ - project_description: The full project description
+ - project_type: The type of project (Web Application, Mobile App, etc)
+ - budget_range: The specified budget range
+
+ 2. WAIT for the analysis to complete before proceeding.
+
+ 3. Review the analysis results and provide strategic recommendations.
+ """,
+ tools=[AnalyzeProjectRequirements],
+ api_headers=api_headers,
+ temperature=0.7,
+ max_prompt_tokens=25000
+ )
+
+ cto = Agent(
+ name="Technical Architect",
+ description="Senior technical architect with deep expertise in system design.",
+ instructions="""
+ You are a technical architect. Follow these steps strictly:
+
+ 1. WAIT for the project analysis to be completed by the CEO.
+
+ 2. Use the CreateTechnicalSpecification tool with:
+ - architecture_type: Choose from monolithic/microservices/serverless/hybrid
+ - core_technologies: List main technologies as comma-separated values
+ - scalability_requirements: Choose high/medium/low based on project needs
+
+ 3. Review the technical specification and provide additional recommendations.
+ """,
+ tools=[CreateTechnicalSpecification],
+ api_headers=api_headers,
+ temperature=0.5,
+ max_prompt_tokens=25000
+ )
+
+ product_manager = Agent(
+ name="Product Manager",
+ description="Experienced product manager focused on delivery excellence.",
+ instructions="""
+ - Manage project scope and timeline giving the roadmap of the project
+ - Define product requirements and you should give potential products and features that can be built for the startup
+ """,
+ api_headers=api_headers,
+ temperature=0.4,
+ max_prompt_tokens=25000
+ )
+
+ developer = Agent(
+ name="Lead Developer",
+ description="Senior developer with full-stack expertise.",
+ instructions="""
+ - Plan technical implementation
+ - Provide effort estimates
+ - Review technical feasibility
+ """,
+ api_headers=api_headers,
+ temperature=0.3,
+ max_prompt_tokens=25000
+ )
+
+ client_manager = Agent(
+ name="Client Success Manager",
+ description="Experienced client manager focused on project delivery.",
+ instructions="""
+ - Ensure client satisfaction
+ - Manage expectations
+ - Handle feedback
+ """,
+ api_headers=api_headers,
+ temperature=0.6,
+ max_prompt_tokens=25000
+ )
+
+ # Create agency
+ agency = Agency(
+ [
+ ceo, cto, product_manager, developer, client_manager,
+ [ceo, cto],
+ [ceo, product_manager],
+ [ceo, developer],
+ [ceo, client_manager],
+ [cto, developer],
+ [product_manager, developer],
+ [product_manager, client_manager]
+ ],
+ async_mode='threading',
+ shared_files='shared_files'
+ )
+
+ # Prepare project info
+ project_info = {
+ "name": project_name,
+ "description": project_description,
+ "type": project_type,
+ "timeline": timeline,
+ "budget": budget_range,
+ "priority": priority,
+ "technical_requirements": tech_requirements,
+ "special_considerations": special_considerations
+ }
+
+ st.session_state.messages.append({"role": "user", "content": str(project_info)})
+ # Create tabs and run analysis
+ with st.spinner("AI Services Agency is analyzing your project..."):
+ try:
+ # Get analysis from each agent using agency.get_completion()
+ ceo_response = agency.get_completion(
+ message=f"""Analyze this project using the AnalyzeProjectRequirements tool:
+ Project Name: {project_name}
+ Project Description: {project_description}
+ Project Type: {project_type}
+ Budget Range: {budget_range}
+
+ Use these exact values with the tool and wait for the analysis results.""",
+ recipient_agent=ceo
+ )
+
+ cto_response = agency.get_completion(
+ message=f"""Review the project analysis and create technical specifications using the CreateTechnicalSpecification tool.
+ Choose the most appropriate:
+ - architecture_type (monolithic/microservices/serverless/hybrid)
+ - core_technologies (comma-separated list)
+ - scalability_requirements (high/medium/low)
+
+ Base your choices on the project requirements and analysis.""",
+ recipient_agent=cto
+ )
+
+ pm_response = agency.get_completion(
+ message=f"Analyze project management aspects: {str(project_info)}",
+ recipient_agent=product_manager,
+ additional_instructions="Focus on product-market fit and roadmap development, and coordinate with technical and marketing teams."
+ )
+
+ developer_response = agency.get_completion(
+ message=f"Analyze technical implementation based on CTO's specifications: {str(project_info)}",
+ recipient_agent=developer,
+ additional_instructions="Provide technical implementation details, optimal tech stack you would be using including the costs of cloud services (if any) and feasibility feedback, and coordinate with product manager and CTO to build the required products for the startup."
+ )
+
+ client_response = agency.get_completion(
+ message=f"Analyze client success aspects: {str(project_info)}",
+ recipient_agent=client_manager,
+ additional_instructions="Provide detailed go-to-market strategy and customer acquisition plan, and coordinate with product manager."
+ )
+
+ # Create tabs for different analyses
+ tabs = st.tabs([
+ "CEO's Project Analysis",
+ "CTO's Technical Specification",
+ "Product Manager's Plan",
+ "Developer's Implementation",
+ "Client Success Strategy"
+ ])
+
+ with tabs[0]:
+ st.markdown("## CEO's Strategic Analysis")
+ st.markdown(ceo_response)
+ st.session_state.messages.append({"role": "assistant", "content": ceo_response})
+
+ with tabs[1]:
+ st.markdown("## CTO's Technical Specification")
+ st.markdown(cto_response)
+ st.session_state.messages.append({"role": "assistant", "content": cto_response})
+
+ with tabs[2]:
+ st.markdown("## Product Manager's Plan")
+ st.markdown(pm_response)
+ st.session_state.messages.append({"role": "assistant", "content": pm_response})
+
+ with tabs[3]:
+ st.markdown("## Lead Developer's Development Plan")
+ st.markdown(developer_response)
+ st.session_state.messages.append({"role": "assistant", "content": developer_response})
+
+ with tabs[4]:
+ st.markdown("## Client Success Strategy")
+ st.markdown(client_response)
+ st.session_state.messages.append({"role": "assistant", "content": client_response})
+
+ except Exception as e:
+ st.error(f"Error during analysis: {str(e)}")
+ st.error("Please check your inputs and API key and try again.")
+
+ except Exception as e:
+ st.error(f"Error during analysis: {str(e)}")
+ st.error("Please check your API key and try again.")
+
+ # Add history management in sidebar
+ with st.sidebar:
+ st.subheader("Options")
+ if st.checkbox("Show Analysis History"):
+ for message in st.session_state.messages:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ if st.button("Clear History"):
+ st.session_state.messages = []
+ st.rerun()
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_services_agency/requirements.txt b/ai_agent_tutorials/ai_services_agency/requirements.txt
new file mode 100644
index 0000000..a41c04a
--- /dev/null
+++ b/ai_agent_tutorials/ai_services_agency/requirements.txt
@@ -0,0 +1,3 @@
+python-dotenv==1.0.1
+agency-swarm==0.4.1
+streamlit
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_startup_trend_analysis_agent/README.md b/ai_agent_tutorials/ai_startup_trend_analysis_agent/README.md
new file mode 100644
index 0000000..5402738
--- /dev/null
+++ b/ai_agent_tutorials/ai_startup_trend_analysis_agent/README.md
@@ -0,0 +1,42 @@
+## ๐ AI Startup Trend Analysis Agent
+The AI Startup Trend Analysis Agent is tool for budding entrepreneurs that generates actionable insights by identifying nascent trends, potential market gaps, and growth opportunities in specific sectors. Entrepreneurs can use these data-driven insights to validate ideas, spot market opportunities, and make informed decisions about their startup ventures. It combines Newspaper4k and DuckDuckGo to scan and analyze startup-focused articles and market data. Using Claude 3.5 Sonnet, it processes this information to extract emerging patterns and enable entrepreneurs to identify promising startup opportunities.
+
+
+### Features
+- **User Prompt**: Entrepreneurs can input specific startup sectors or technologies of interest for research.
+- **News Collection**: This agent gathers recent startup news, funding rounds, and market analyses using DuckDuckGo.
+- **Summary Generation**: Concise summaries of verified information are generated using Newspaper4k.
+- **Trend Analysis**: The system identifies emerging patterns in startup funding, technology adoption, and market opportunities across analyzed stories.
+- **Streamlit UI**: The application features a user-friendly interface built with Streamlit for easy interaction.
+
+### How to Get Started
+1. **Clone the repository**:
+ ```bash
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd awesome-llm-apps/ai_agent_tutorials/ai_startup_trend_analysis_agent
+ ```
+
+2. **Create and activate a virtual environment**:
+ ```bash
+ # For macOS/Linux
+ python -m venv venv
+ source venv/bin/activate
+
+ # For Windows
+ python -m venv venv
+ .\venv\Scripts\activate
+ ```
+
+3. **Install the required packages**:
+ ```bash
+ pip install -r requirements.txt
+ ```
+
+4. **Run the application**:
+ ```bash
+ streamlit run startup_trends_agent.py
+ ```
+### Important Note
+- The system specifically uses Claude's API for advanced language processing. You can obtain your Anthropic API key from [Anthropic's website](https://www.anthropic.com/api).
+
+
diff --git a/ai_agent_tutorials/ai_startup_trend_analysis_agent/requirements.txt b/ai_agent_tutorials/ai_startup_trend_analysis_agent/requirements.txt
new file mode 100644
index 0000000..00ecb40
--- /dev/null
+++ b/ai_agent_tutorials/ai_startup_trend_analysis_agent/requirements.txt
@@ -0,0 +1,5 @@
+agno
+streamlit==1.40.2
+duckduckgo_search==6.3.7
+newspaper4k==0.9.3.1
+lxml_html_clean==0.4.1
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_startup_trend_analysis_agent/startup_trends_agent.py b/ai_agent_tutorials/ai_startup_trend_analysis_agent/startup_trends_agent.py
new file mode 100644
index 0000000..8b9a722
--- /dev/null
+++ b/ai_agent_tutorials/ai_startup_trend_analysis_agent/startup_trends_agent.py
@@ -0,0 +1,99 @@
+import streamlit as st
+from agno.agent import Agent
+from agno.tools.duckduckgo import DuckDuckGoTools
+from agno.models.anthropic import Claude
+from agno.tools.newspaper4k import Newspaper4kTools
+from agno.tools import Tool
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+
+# Setting up Streamlit app
+st.title("AI Startup Trend Analysis Agent ๐")
+st.caption("Get the latest trend analysis and startup opportunities based on your topic of interest in a click!.")
+
+topic = st.text_input("Enter the area of interest for your Startup:")
+anthropic_api_key = st.sidebar.text_input("Enter Anthropic API Key", type="password")
+
+if st.button("Generate Analysis"):
+ if not anthropic_api_key:
+ st.warning("Please enter the required API key.")
+ else:
+ with st.spinner("Processing your request..."):
+ try:
+ # Initialize Anthropic model
+ anthropic_model = Claude(id ="claude-3-5-sonnet-20240620",api_key=anthropic_api_key)
+
+ # Define News Collector Agent - Duckduckgo_search tool enables an Agent to search the web for information.
+ search_tool = DuckDuckGoTools(search=True, news=True, fixed_max_results=5)
+ news_collector = Agent(
+ name="News Collector",
+ role="Collects recent news articles on the given topic",
+ tools=[search_tool],
+ model=anthropic_model,
+ instructions=["Gather latest articles on the topic"],
+ show_tool_calls=True,
+ markdown=True,
+ )
+
+ # Define Summary Writer Agent
+ news_tool = Newspaper4kTools(read_article=True, include_summary=True)
+ summary_writer = Agent(
+ name="Summary Writer",
+ role="Summarizes collected news articles",
+ tools=[news_tool],
+ model=anthropic_model,
+ instructions=["Provide concise summaries of the articles"],
+ show_tool_calls=True,
+ markdown=True,
+ )
+
+ # Define Trend Analyzer Agent
+ trend_analyzer = Agent(
+ name="Trend Analyzer",
+ role="Analyzes trends from summaries",
+ model=anthropic_model,
+ instructions=["Identify emerging trends and startup opportunities"],
+ show_tool_calls=True,
+ markdown=True,
+ )
+
+ # The multi agent Team setup of phidata:
+ agent_team = Agent(
+ agents=[news_collector, summary_writer, trend_analyzer],
+ instructions=[
+ "First, search DuckDuckGo for recent news articles related to the user's specified topic.",
+ "Then, provide the collected article links to the summary writer.",
+ "Important: you must ensure that the summary writer receives all the article links to read.",
+ "Next, the summary writer will read the articles and prepare concise summaries of each.",
+ "After summarizing, the summaries will be passed to the trend analyzer.",
+ "Finally, the trend analyzer will identify emerging trends and potential startup opportunities based on the summaries provided in a detailed Report form so that any young entreprenur can get insane value reading this easily"
+ ],
+ show_tool_calls=True,
+ markdown=True,
+ )
+
+ # Executing the workflow
+ # Step 1: Collect news
+ news_response = news_collector.run(f"Collect recent news on {topic}")
+ articles = news_response.content
+
+ # Step 2: Summarize articles
+ summary_response = summary_writer.run(f"Summarize the following articles:\n{articles}")
+ summaries = summary_response.content
+
+ # Step 3: Analyze trends
+ trend_response = trend_analyzer.run(f"Analyze trends from the following summaries:\n{summaries}")
+ analysis = trend_response.content
+
+ # Display results - if incase you want to use this furthur, you can uncomment the below 2 lines to get the summaries too!
+ # st.subheader("News Summaries")
+ # # st.write(summaries)
+
+ st.subheader("Trend Analysis and Potential Startup Opportunities")
+ st.write(analysis)
+
+ except Exception as e:
+ st.error(f"An error occurred: {e}")
+else:
+ st.info("Enter the topic and API keys, then click 'Generate Analysis' to start.")
diff --git a/ai_agent_tutorials/ai_system_architect_r1/README.md b/ai_agent_tutorials/ai_system_architect_r1/README.md
new file mode 100644
index 0000000..a78e925
--- /dev/null
+++ b/ai_agent_tutorials/ai_system_architect_r1/README.md
@@ -0,0 +1,74 @@
+# ๐ค AI System Architect Advisor with R1
+
+An Agno agentic system that provides expert software architecture analysis and recommendations using a dual-model approach combining DeepSeek R1's Reasoning and Claude. The system provides detailed technical analysis, implementation roadmaps, and architectural decisions for complex software systems.
+
+## Features
+
+- **Dual AI Model Architecture**
+ - **DeepSeek Reasoner**: Provides initial technical analysis and structured reasoning about architecture patterns, tools, and implementation strategies
+ - **Claude-3.5**: Generates detailed explanations, implementation roadmaps, and technical specifications based on DeepSeek's analysis
+
+- **Comprehensive Analysis Components**
+ - Architecture Pattern Selection
+ - Infrastructure Resource Planning
+ - Security Measures and Compliance
+ - Database Architecture
+ - Performance Requirements
+ - Cost Estimation
+ - Risk Assessment
+
+- **Analysis Types**
+ - Real-time Event Processing Systems
+ - Healthcare Data Platforms
+ - Financial Trading Platforms
+ - Multi-tenant SaaS Solutions
+ - Digital Content Delivery Networks
+ - Supply Chain Management Systems
+
+## How to Run
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd awesome-llm-apps/ai_agent_tutorials/ai_system_architect_r1
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+2. **Configure API Keys**
+ - Get DeepSeek API key from DeepSeek platform
+ - Get Anthropic API key from [Anthropic Platform](https://www.anthropic.com)
+
+3. **Run the Application**
+ ```bash
+ streamlit run ai_system_architect_r1.py
+ ```
+
+4. **Use the Interface**
+ - Enter API credentials in sidebar
+ - Structure your prompt with:
+ - Project Context
+ - Requirements
+ - Constraints
+ - Scale
+ - Security/Compliance needs
+ - View detailed analysis results
+
+## Example Test Prompts:
+
+### 1. Financial Trading Platform
+"We need to build a high-frequency trading platform that processes market data streams, executes trades with sub-millisecond latency, maintains audit trails, and handles complex risk calculations. The system needs to be globally distributed, handle 100,000 transactions per second, and have robust disaster recovery capabilities."
+### 2. Multi-tenant SaaS Platform
+"Design a multi-tenant SaaS platform for enterprise resource planning that needs to support customization per tenant, handle different data residency requirements, support offline capabilities, and maintain performance isolation between tenants. The system should scale to 10,000 concurrent users and support custom integrations."
+
+## Notes
+
+- Requires both DeepSeek and Anthropic API keys
+- Provides real-time analysis with detailed explanations
+- Supports chat-based interaction
+- Includes clear reasoning for all architectural decisions
+- API usage costs apply
+
+
diff --git a/ai_agent_tutorials/ai_system_architect_r1/ai_system_architect_r1.py b/ai_agent_tutorials/ai_system_architect_r1/ai_system_architect_r1.py
new file mode 100644
index 0000000..5236c94
--- /dev/null
+++ b/ai_agent_tutorials/ai_system_architect_r1/ai_system_architect_r1.py
@@ -0,0 +1,315 @@
+from typing import Optional, List, Dict, Any, Union
+import os
+import time
+import streamlit as st
+from openai import OpenAI
+import anthropic
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from enum import Enum
+import json
+from agno.agent import Agent, RunResponse
+from agno.models.anthropic import Claude
+
+# Model Constants
+DEEPSEEK_MODEL: str = "deepseek-reasoner"
+CLAUDE_MODEL: str = "claude-3-5-sonnet-20241022"
+
+class ArchitecturePattern(str, Enum):
+ """Architectural patterns for system design."""
+ MICROSERVICES = "microservices" # Decomposed into small, independent services
+ MONOLITHIC = "monolithic" # Single, unified codebase
+ SERVERLESS = "serverless" # Function-as-a-Service architecture
+ EVENT_DRIVEN = "event_driven" # Asynchronous event-based communication
+
+class DatabaseType(str, Enum):
+ """Types of database systems."""
+ SQL = "sql" # Relational databases with ACID properties
+ NOSQL = "nosql" # Non-relational databases for flexible schemas
+ HYBRID = "hybrid" # Combined SQL and NoSQL approach
+
+class ComplianceStandard(str, Enum):
+ """Regulatory compliance standards."""
+ HIPAA = "hipaa" # Healthcare data protection
+ GDPR = "gdpr" # EU data privacy regulation
+ SOC2 = "soc2" # Service organization security controls
+ ISO27001 = "iso27001" # Information security management
+
+class ArchitectureDecision(BaseModel):
+ """Represents architectural decisions and their justifications."""
+ pattern: ArchitecturePattern
+ rationale: str = Field(..., min_length=50) # Detailed explanation for the choice
+ trade_offs: Dict[str, List[str]] = Field(..., alias="trade_offs") # Pros and cons
+ estimated_cost: Dict[str, float] # Cost breakdown
+
+class SecurityMeasure(BaseModel):
+ """Security controls and implementation details."""
+ measure_type: str # Type of security measure
+ implementation_priority: int = Field(..., ge=1, le=5) # Priority level 1-5
+ compliance_standards: List[ComplianceStandard] # Applicable standards
+ data_classification: str # Data sensitivity level
+
+class InfrastructureResource(BaseModel):
+ """Infrastructure components and specifications."""
+ resource_type: str # Type of infrastructure resource
+ specifications: Dict[str, str] # Technical specifications
+ scaling_policy: Dict[str, str] # Scaling rules and thresholds
+ estimated_cost: float # Estimated cost per resource
+
+class TechnicalAnalysis(BaseModel):
+ """Complete technical analysis of the system architecture."""
+ architecture_decision: ArchitectureDecision # Core architecture choices
+ infrastructure_resources: List[InfrastructureResource] # Required resources
+ security_measures: List[SecurityMeasure] # Security controls
+ database_choice: DatabaseType # Database architecture
+ compliance_requirements: List[ComplianceStandard] = [] # Required standards
+ performance_requirements: List[Dict[str, Union[str, float]]] = [] # Performance metrics
+ risk_assessment: Dict[str, str] = {} # Identified risks and mitigations
+
+
+class ModelChain:
+ def __init__(self, deepseek_api_key: str, anthropic_api_key: str) -> None:
+ self.client = OpenAI(
+ api_key=deepseek_api_key,
+ base_url="https://api.deepseek.com"
+ )
+ self.claude_client = anthropic.Anthropic(api_key=anthropic_api_key)
+
+ # Create Claude model with system prompt
+ claude_model = Claude(
+ id="claude-3-5-sonnet-20241022",
+ api_key=anthropic_api_key,
+ system_prompt="""Given the user's query and the DeepSeek reasoning:
+ 1. Provide a detailed analysis of the architecture decisions
+ 2. Generate a project implementation roadmap
+ 3. Create a comprehensive technical specification document
+ 4. Format the output in clean markdown with proper sections
+ 5. Include diagrams descriptions in mermaid.js format"""
+ )
+
+ # Initialize agent with configured model
+ self.agent = Agent(
+ model=claude_model,
+ markdown=True
+ )
+
+ self.deepseek_messages: List[Dict[str, str]] = []
+ self.claude_messages: List[Dict[str, Any]] = []
+ self.current_model: str = CLAUDE_MODEL
+ def get_deepseek_reasoning(self, user_input: str) -> tuple[str, str]:
+ start_time = time.time()
+
+ system_prompt = """You are an expert software architect and technical advisor. Analyze the user's project requirements
+ and provide structured reasoning about architecture, tools, and implementation strategies.
+
+ IMPORTANT: Reason why you are choosing a particular architecture pattern, database type, etc. for user understanding in your reasoning.
+
+ IMPORTANT: Your response must be a valid JSON object (not a string or any other format) that matches the schema provided below.
+ Do not include any explanatory text, markdown formatting, or code blocks - only return the JSON object.
+
+ Schema:
+ {
+ "architecture_decision": {
+ "pattern": "one of: microservices|monolithic|serverless|event_driven|layered",
+ "rationale": "string",
+ "trade_offs": {"advantage": ["list of strings"], "disadvantage": ["list of strings"]},
+ "estimated_cost": {"implementation": float, "maintenance": float}
+ },
+ "infrastructure_resources": [{
+ "resource_type": "string",
+ "specifications": {"key": "value"},
+ "scaling_policy": {"key": "value"},
+ "estimated_cost": float
+ }],
+ "security_measures": [{
+ "measure_type": "string",
+ "implementation_priority": "integer 1-5",
+ "compliance_standards": ["hipaa", "gdpr", "soc2", "hitech", "iso27001", "pci_dss"],
+ "estimated_setup_time_days": "integer",
+ "data_classification": "one of: protected_health_information|personally_identifiable_information|confidential|public",
+ "encryption_requirements": {"key": "value"},
+ "access_control_policy": {"role": ["permissions"]},
+ "audit_requirements": ["list of strings"]
+ }],
+ "database_choice": "one of: sql|nosql|graph|time_series|hybrid",
+ "ml_capabilities": [{
+ "model_type": "string",
+ "training_frequency": "string",
+ "input_data_types": ["list of strings"],
+ "performance_requirements": {"metric": float},
+ "hardware_requirements": {"resource": "specification"},
+ "regulatory_constraints": ["list of strings"]
+ }],
+ "data_integrations": [{
+ "integration_type": "one of: hl7|fhir|dicom|rest|soap|custom",
+ "data_format": "string",
+ "frequency": "string",
+ "volume": "string",
+ "security_requirements": {"key": "value"}
+ }],
+ "performance_requirements": [{
+ "metric_name": "string",
+ "target_value": float,
+ "measurement_unit": "string",
+ "priority": "integer 1-5"
+ }],
+ "audit_config": {
+ "log_retention_period": "integer",
+ "audit_events": ["list of strings"],
+ "compliance_mapping": {"standard": ["requirements"]}
+ },
+ "api_config": {
+ "version": "string",
+ "auth_method": "string",
+ "rate_limits": {"role": "requests_per_minute"},
+ "documentation_url": "string"
+ },
+ "error_handling": {
+ "retry_policy": {"key": "value"},
+ "fallback_strategies": ["list of strings"],
+ "notification_channels": ["list of strings"]
+ },
+ "estimated_team_size": "integer",
+ "critical_path_components": ["list of strings"],
+ "risk_assessment": {"risk": "mitigation"},
+ "maintenance_considerations": ["list of strings"],
+ "compliance_requirements": ["list of compliance standards"],
+ "data_retention_policy": {"data_type": "retention_period"},
+ "disaster_recovery": {"key": "value"},
+ "interoperability_standards": ["list of strings"]
+ }
+
+ Consider scalability, security, maintenance, and technical debt in your analysis.
+ Focus on practical, modern solutions while being mindful of trade-offs."""
+
+ try:
+ deepseek_response = self.client.chat.completions.create(
+ model="deepseek-reasoner",
+ messages=[
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": user_input}
+ ],
+ max_tokens=3000,
+ stream=False
+ )
+
+ reasoning_content = deepseek_response.choices[0].message.reasoning_content
+ normal_content = deepseek_response.choices[0].message.content
+
+ # Display the reasoning separately
+ with st.expander("DeepSeek Reasoning", expanded=True):
+ st.markdown(reasoning_content)
+
+
+ with st.expander("๐ญ Technical Analysis", expanded=True):
+ st.markdown(normal_content)
+ elapsed_time = time.time() - start_time
+ time_str = f"{elapsed_time/60:.1f} minutes" if elapsed_time >= 60 else f"{elapsed_time:.1f} seconds"
+ st.caption(f"โฑ๏ธ Analysis completed in {time_str}")
+
+ # Return both reasoning and normal content
+ return reasoning_content, normal_content
+
+ except Exception as e:
+ st.error(f"Error in DeepSeek analysis: {str(e)}")
+ return "Error occurred while analyzing", ""
+
+ def get_claude_response(self, user_input: str, deepseek_output: tuple[str, str]) -> str:
+ try:
+ reasoning_content, normal_content = deepseek_output
+
+ # Create expander for Claude's response
+ with st.expander("๐ค Claude's Response", expanded=True):
+ response_placeholder = st.empty()
+
+ # Prepare the message with user input, reasoning and normal output
+ message = f"""User Query: {user_input}
+
+ DeepSeek Reasoning: {reasoning_content}
+
+ DeepSeek Technical Analysis: {normal_content}
+ Give detailed explanation for each key value pair in brief in the JSON object, and why we chose it clearly. Dont use your own opinions, use the reasoning and the structured output to explain the choices."""
+
+ # Use Phi Agent to get response
+ response: RunResponse = self.agent.run(
+ message=message
+ )
+
+ dub = response.content
+ st.markdown(dub)
+ return dub
+
+ except Exception as e:
+ st.error(f"Error in Claude response: {str(e)}")
+ return "Error occurred while getting response"
+
+def main() -> None:
+ """Main function to run the Streamlit app."""
+ st.title("๐ค AI System Architect Advisor with R1")
+
+ # Add prompt guidance
+ st.info("""
+ ๐ For best results, structure your prompt with:
+
+ 1. **Project Context**: Brief description of your project/system
+ 2. **Requirements**: Key functional and non-functional requirements
+ 3. **Constraints**: Any technical, budget, or time constraints
+ 4. **Scale**: Expected user base and growth projections
+ 5. **Security/Compliance**: Any specific security or regulatory needs
+
+ Example:
+ ```
+ I need to build a healthcare data management system that:
+ - Handles patient records and appointments
+ - Needs to scale to 10,000 users
+ - Must be HIPAA compliant
+ - Budget constraint of $50k for initial setup
+ - Should integrate with existing hospital systems
+ ```
+ """)
+
+ # Sidebar for API keys
+ with st.sidebar:
+ st.header("โ๏ธ Configuration")
+ deepseek_api_key = st.text_input("DeepSeek API Key", type="password")
+ anthropic_api_key = st.text_input("Anthropic API Key", type="password")
+
+ if st.button("๐๏ธ Clear Chat History"):
+ st.session_state.messages = []
+ st.rerun()
+
+ # Initialize session state for messages
+ if "messages" not in st.session_state:
+ st.session_state.messages = []
+
+ # Display chat messages
+ for message in st.session_state.messages:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ # Chat input
+ if prompt := st.chat_input("What would you like to know?"):
+ if not deepseek_api_key or not anthropic_api_key:
+ st.error("โ ๏ธ Please enter both API keys in the sidebar.")
+ return
+
+ # Initialize ModelChain
+ chain = ModelChain(deepseek_api_key, anthropic_api_key)
+
+ # Add user message to chat
+ st.session_state.messages.append({"role": "user", "content": prompt})
+ with st.chat_message("user"):
+ st.markdown(prompt)
+
+ # Get AI response
+ with st.chat_message("assistant"):
+ with st.spinner("๐ค Thinking..."):
+ deepseek_output = chain.get_deepseek_reasoning(prompt)
+
+
+ with st.spinner("โ๏ธ Responding..."):
+ response = chain.get_claude_response(prompt, deepseek_output)
+ st.session_state.messages.append({"role": "assistant", "content": response})
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_system_architect_r1/requirements.txt b/ai_agent_tutorials/ai_system_architect_r1/requirements.txt
new file mode 100644
index 0000000..e8fce4b
--- /dev/null
+++ b/ai_agent_tutorials/ai_system_architect_r1/requirements.txt
@@ -0,0 +1,4 @@
+streamlit
+openai
+anthropic
+agno
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_teaching_agent_team/README.md b/ai_agent_tutorials/ai_teaching_agent_team/README.md
new file mode 100644
index 0000000..5a67383
--- /dev/null
+++ b/ai_agent_tutorials/ai_teaching_agent_team/README.md
@@ -0,0 +1,75 @@
+# ๐จโ๐ซ AI Teaching Agent Team
+
+A Streamlit application that brings together a team of specialized AI teaching agents who collaborate like a professional teaching faculty. Each agent acts as a specialized educator: a curriculum designer, learning path expert, resource librarian, and practice instructor - working together to create a complete educational experience through Google Docs.
+
+## ๐ช Meet your AI Teaching Agent Team
+
+#### ๐ง Professor Agent
+- Creates fundamental knowledge base in Google Docs
+- Organizes content with proper headings and sections
+- Includes detailed explanations and examples
+- Output: Comprehensive knowledge base document with table of contents
+
+#### ๐บ๏ธ Academic Advisor Agent
+- Designs learning path in a structured Google Doc
+- Creates progressive milestone markers
+- Includes time estimates and prerequisites
+- Output: Visual roadmap document with clear progression paths
+
+#### ๐ Research Librarian Agent
+- Compiles resources in an organized Google Doc
+- Includes links to academic papers and tutorials
+- Adds descriptions and difficulty levels
+- Output: Categorized resource list with quality ratings
+
+#### โ๏ธ Teaching Assistant Agent
+- Develops exercises in an interactive Google Doc
+- Creates structured practice sections
+- Includes solution guides
+- Output: Complete practice workbook with answers
+
+
+## How to Run
+
+1. Clone the repository
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_personal_learning_agent
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+## Configuration - IMPORTANT STEP
+
+1. Get your OpenAI API Key
+- Create an account on [OpenAI Platform](https://platform.openai.com/)
+- Navigate to API Keys section
+- Create a new API key
+
+2. Get your Composio API Key
+- Create an account on [Composio Platform](https://composio.ai/)
+- **IMPORTANT** - For you to use the app, you need to make new connection ID with google docs and composio.Follow the below two steps to do so:
+ - composio add googledocs (IN THE TERMINAL)
+ - Create a new connection
+ - Select OAUTH2
+ - Select Google Account and Done.
+ - On the composio account website, go to apps, select google docs tool, and [click create integration](https://app.composio.dev/app/googledocs) (violet button) and click Try connecting defaultโs googldocs button and we are done.
+
+3. Sign up and get the [SerpAPI Key](https://serpapi.com/)
+
+## How to Use?
+
+1. Start the Streamlit app
+```bash
+streamlit run teaching_agent_team.py
+```
+
+2. Use the application
+- Enter your OpenAI API key in the sidebar (if not set in environment)
+- Enter your Composio API key in the sidebar
+- Type a topic you want to learn about (e.g., "Python Programming", "Machine Learning")
+- Click "Generate Learning Plan"
+- Wait for the agents to generate your personalized learning plan
+- View the results and terminal output in the interface
diff --git a/ai_agent_tutorials/ai_teaching_agent_team/requirements.txt b/ai_agent_tutorials/ai_teaching_agent_team/requirements.txt
new file mode 100644
index 0000000..7b16c6c
--- /dev/null
+++ b/ai_agent_tutorials/ai_teaching_agent_team/requirements.txt
@@ -0,0 +1,9 @@
+streamlit==1.41.1
+openai==1.58.1
+duckduckgo-search==6.4.1
+typing-extensions>=4.5.0
+agno
+composio-phidata==0.6.9
+composio_core
+composio==0.1.1
+google-search-results==2.4.2
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_teaching_agent_team/teaching_agent_team.py b/ai_agent_tutorials/ai_teaching_agent_team/teaching_agent_team.py
new file mode 100644
index 0000000..8306ae3
--- /dev/null
+++ b/ai_agent_tutorials/ai_teaching_agent_team/teaching_agent_team.py
@@ -0,0 +1,210 @@
+import streamlit as st
+from agno.agent import Agent, RunResponse
+from agno.models.openai import OpenAIChat
+from composio_phidata import Action, ComposioToolSet
+import os
+from agno.tools.arxiv import ArxivTools
+from agno.utils.pprint import pprint_run_response
+from agno.tools.serpapi import SerpApiTools
+
+# Set page configuration
+st.set_page_config(page_title="๐จโ๐ซ AI Teaching Agent Team", layout="centered")
+
+# Initialize session state for API keys and topic
+if 'openai_api_key' not in st.session_state:
+ st.session_state['openai_api_key'] = ''
+if 'composio_api_key' not in st.session_state:
+ st.session_state['composio_api_key'] = ''
+if 'serpapi_api_key' not in st.session_state:
+ st.session_state['serpapi_api_key'] = ''
+if 'topic' not in st.session_state:
+ st.session_state['topic'] = ''
+
+# Streamlit sidebar for API keys
+with st.sidebar:
+ st.title("API Keys Configuration")
+ st.session_state['openai_api_key'] = st.text_input("Enter your OpenAI API Key", type="password").strip()
+ st.session_state['composio_api_key'] = st.text_input("Enter your Composio API Key", type="password").strip()
+ st.session_state['serpapi_api_key'] = st.text_input("Enter your SerpAPI Key", type="password").strip()
+
+ # Add info about terminal responses
+ st.info("Note: You can also view detailed agent responses\nin your terminal after execution.")
+
+# Validate API keys
+if not st.session_state['openai_api_key'] or not st.session_state['composio_api_key'] or not st.session_state['serpapi_api_key']:
+ st.error("Please enter OpenAI, Composio, and SerpAPI keys in the sidebar.")
+ st.stop()
+
+# Set the OpenAI API key and Composio API key from session state
+os.environ["OPENAI_API_KEY"] = st.session_state['openai_api_key']
+
+try:
+ composio_toolset = ComposioToolSet(api_key=st.session_state['composio_api_key'])
+ google_docs_tool = composio_toolset.get_tools(actions=[Action.GOOGLEDOCS_CREATE_DOCUMENT])[0]
+ google_docs_tool_update = composio_toolset.get_tools(actions=[Action.GOOGLEDOCS_UPDATE_EXISTING_DOCUMENT])[0]
+except Exception as e:
+ st.error(f"Error initializing ComposioToolSet: {e}")
+ st.stop()
+
+# Create the Professor agent (formerly KnowledgeBuilder)
+professor_agent = Agent(
+ name="Professor",
+ role="Research and Knowledge Specialist",
+ model=OpenAIChat(id="gpt-4o-mini", api_key=st.session_state['openai_api_key']),
+ tools=[google_docs_tool],
+ instructions=[
+ "Create a comprehensive knowledge base that covers fundamental concepts, advanced topics, and current developments of the given topic.",
+ "Exlain the topic from first principles first. Include key terminology, core principles, and practical applications and make it as a detailed report that anyone who's starting out can read and get maximum value out of it.",
+ "Make sure it is formatted in a way that is easy to read and understand. DONT FORGET TO CREATE THE GOOGLE DOCUMENT.",
+ "Open a new Google Doc and write down the response of the agent neatly with great formatting and structure in it. **Include the Google Doc link in your response.**",
+ ],
+ show_tool_calls=True,
+ markdown=True,
+)
+
+# Create the Academic Advisor agent (formerly RoadmapArchitect)
+academic_advisor_agent = Agent(
+ name="Academic Advisor",
+ role="Learning Path Designer",
+ model=OpenAIChat(id="gpt-4o-mini", api_key=st.session_state['openai_api_key']),
+ tools=[google_docs_tool],
+ instructions=[
+ "Using the knowledge base for the given topic, create a detailed learning roadmap.",
+ "Break down the topic into logical subtopics and arrange them in order of progression, a detailed report of roadmap that includes all the subtopics in order to be an expert in this topic.",
+ "Include estimated time commitments for each section.",
+ "Present the roadmap in a clear, structured format. DONT FORGET TO CREATE THE GOOGLE DOCUMENT.",
+ "Open a new Google Doc and write down the response of the agent neatly with great formatting and structure in it. **Include the Google Doc link in your response.**",
+
+ ],
+ show_tool_calls=True,
+ markdown=True
+)
+
+# Create the Research Librarian agent (formerly ResourceCurator)
+research_librarian_agent = Agent(
+ name="Research Librarian",
+ role="Learning Resource Specialist",
+ model=OpenAIChat(id="gpt-4o-mini", api_key=st.session_state['openai_api_key']),
+ tools=[google_docs_tool, SerpApiTools(api_key=st.session_state['serpapi_api_key']) ],
+ instructions=[
+ "Make a list of high-quality learning resources for the given topic.",
+ "Use the SerpApi search tool to find current and relevant learning materials.",
+ "Using SerpApi search tool, Include technical blogs, GitHub repositories, official documentation, video tutorials, and courses.",
+ "Present the resources in a curated list with descriptions and quality assessments. DONT FORGET TO CREATE THE GOOGLE DOCUMENT.",
+ "Open a new Google Doc and write down the response of the agent neatly with great formatting and structure in it. **Include the Google Doc link in your response.**",
+ ],
+ show_tool_calls=True,
+ markdown=True,
+)
+
+# Create the Teaching Assistant agent (formerly PracticeDesigner)
+teaching_assistant_agent = Agent(
+ name="Teaching Assistant",
+ role="Exercise Creator",
+ model=OpenAIChat(id="gpt-4o-mini", api_key=st.session_state['openai_api_key']),
+ tools=[google_docs_tool, SerpApiTools(api_key=st.session_state['serpapi_api_key'])],
+ instructions=[
+ "Create comprehensive practice materials for the given topic.",
+ "Use the SerpApi search tool to find example problems and real-world applications.",
+ "Include progressive exercises, quizzes, hands-on projects, and real-world application scenarios.",
+ "Ensure the materials align with the roadmap progression.",
+ "Provide detailed solutions and explanations for all practice materials.DONT FORGET TO CREATE THE GOOGLE DOCUMENT.",
+ "Open a new Google Doc and write down the response of the agent neatly with great formatting and structure in it. **Include the Google Doc link in your response.**",
+ ],
+ show_tool_calls=True,
+ markdown=True,
+)
+
+# Streamlit main UI
+st.title("๐จโ๐ซ AI Teaching Agent Team")
+st.markdown("Enter a topic to generate a detailed learning path and resources")
+
+# Add info message about Google Docs
+st.info("๐ The agents will create detailed Google Docs for each section (Professor, Academic Advisor, Research Librarian, and Teaching Assistant). The links to these documents will be displayed below after processing.")
+
+# Query bar for topic input
+st.session_state['topic'] = st.text_input("Enter the topic you want to learn about:", placeholder="e.g., Machine Learning, LoRA, etc.")
+
+# Start button
+if st.button("Start"):
+ if not st.session_state['topic']:
+ st.error("Please enter a topic.")
+ else:
+ # Display loading animations while generating responses
+ with st.spinner("Generating Knowledge Base..."):
+ professor_response: RunResponse = professor_agent.run(
+ f"the topic is: {st.session_state['topic']},Don't forget to add the Google Doc link in your response.",
+ stream=False
+ )
+
+ with st.spinner("Generating Learning Roadmap..."):
+ academic_advisor_response: RunResponse = academic_advisor_agent.run(
+ f"the topic is: {st.session_state['topic']},Don't forget to add the Google Doc link in your response.",
+ stream=False
+ )
+
+ with st.spinner("Curating Learning Resources..."):
+ research_librarian_response: RunResponse = research_librarian_agent.run(
+ f"the topic is: {st.session_state['topic']},Don't forget to add the Google Doc link in your response.",
+ stream=False
+ )
+
+ with st.spinner("Creating Practice Materials..."):
+ teaching_assistant_response: RunResponse = teaching_assistant_agent.run(
+ f"the topic is: {st.session_state['topic']},Don't forget to add the Google Doc link in your response.",
+ stream=False
+ )
+
+ # Extract Google Doc links from the responses
+ def extract_google_doc_link(response_content):
+ # Assuming the Google Doc link is embedded in the response content
+ # You may need to adjust this logic based on the actual response format
+ if "https://docs.google.com" in response_content:
+ return response_content.split("https://docs.google.com")[1].split()[0]
+ return None
+
+ professor_doc_link = extract_google_doc_link(professor_response.content)
+ academic_advisor_doc_link = extract_google_doc_link(academic_advisor_response.content)
+ research_librarian_doc_link = extract_google_doc_link(research_librarian_response.content)
+ teaching_assistant_doc_link = extract_google_doc_link(teaching_assistant_response.content)
+
+ # Display Google Doc links at the top of the Streamlit UI
+ st.markdown("### Google Doc Links:")
+ if professor_doc_link:
+ st.markdown(f"- **Professor Document:** [View Document](https://docs.google.com{professor_doc_link})")
+ if academic_advisor_doc_link:
+ st.markdown(f"- **Academic Advisor Document:** [View Document](https://docs.google.com{academic_advisor_doc_link})")
+ if research_librarian_doc_link:
+ st.markdown(f"- **Research Librarian Document:** [View Document](https://docs.google.com{research_librarian_doc_link})")
+ if teaching_assistant_doc_link:
+ st.markdown(f"- **Teaching Assistant Document:** [View Document](https://docs.google.com{teaching_assistant_doc_link})")
+
+ # Display responses in the Streamlit UI using pprint_run_response
+ st.markdown("### Professor Response:")
+ st.markdown(professor_response.content)
+ pprint_run_response(professor_response, markdown=True)
+ st.divider()
+
+ st.markdown("### Academic Advisor Response:")
+ st.markdown(academic_advisor_response.content)
+ pprint_run_response(academic_advisor_response, markdown=True)
+ st.divider()
+
+ st.markdown("### Research Librarian Response:")
+ st.markdown(research_librarian_response.content)
+ pprint_run_response(research_librarian_response, markdown=True)
+ st.divider()
+
+ st.markdown("### Teaching Assistant Response:")
+ st.markdown(teaching_assistant_response.content)
+ pprint_run_response(teaching_assistant_response, markdown=True)
+ st.divider()
+# Information about the agents
+st.markdown("---")
+st.markdown("### About the Agents:")
+st.markdown("""
+- **Professor**: Researches the topic and creates a detailed knowledge base.
+- **Academic Advisor**: Designs a structured learning roadmap for the topic.
+- **Research Librarian**: Curates high-quality learning resources.
+- **Teaching Assistant**: Creates practice materials, exercises, and projects.
+""")
diff --git a/ai_agent_tutorials/ai_tic_tac_toe_agent/README.md b/ai_agent_tutorials/ai_tic_tac_toe_agent/README.md
new file mode 100644
index 0000000..8ba563e
--- /dev/null
+++ b/ai_agent_tutorials/ai_tic_tac_toe_agent/README.md
@@ -0,0 +1,106 @@
+# ๐ฎ Agent X vs Agent O: Tic-Tac-Toe Game
+
+An interactive Tic-Tac-Toe game where two AI agents powered by different language models compete against each other built on Agno Agent Framework and Streamlit as UI.
+
+This example shows how to build an interactive Tic Tac Toe game where AI agents compete against each other. The application showcases how to:
+- Coordinate multiple AI agents in a turn-based game
+- Use different language models for different players
+- Create an interactive web interface with Streamlit
+- Handle game state and move validation
+- Display real-time game progress and move history
+
+## Features
+- Multiple AI models support (GPT-4, Claude, Gemini, etc.)
+- Real-time game visualization
+- Move history tracking with board states
+- Interactive player selection
+- Game state management
+- Move validation and coordination
+
+## How to Run?
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd ai_agent_tutorials/ai_tic_tac_toe_agent
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+### 2. Install dependencies
+
+```shell
+pip install -r requirements.txt
+```
+
+### 3. Export API Keys
+
+The game supports multiple AI models. Export the API keys for the models you want to use:
+
+```shell
+# Required for OpenAI models
+export OPENAI_API_KEY=***
+
+# Optional - for additional models
+export ANTHROPIC_API_KEY=*** # For Claude models
+export GOOGLE_API_KEY=*** # For Gemini models
+export GROQ_API_KEY=*** # For Groq models
+```
+
+### 4. Run the Game
+
+```shell
+streamlit run app.py
+```
+
+- Open [localhost:8501](http://localhost:8501) to view the game interface
+
+## How It Works
+
+The game consists of three agents:
+
+1. **Master Agent (Referee)**
+ - Coordinates the game
+ - Validates moves
+ - Maintains game state
+ - Determines game outcome
+
+2. **Two Player Agents**
+ - Make strategic moves
+ - Analyze board state
+ - Follow game rules
+ - Respond to opponent moves
+
+## Available Models
+
+The game supports various AI models:
+- GPT-4o (OpenAI)
+- GPT-o3-mini (OpenAI)
+- Gemini (Google)
+- Llama 3 (Groq)
+- Claude (Anthropic)
+
+## Game Features
+
+1. **Interactive Board**
+ - Real-time updates
+ - Visual move tracking
+ - Clear game status display
+
+2. **Move History**
+ - Detailed move tracking
+ - Board state visualization
+ - Player action timeline
+
+3. **Game Controls**
+ - Start/Pause game
+ - Reset board
+ - Select AI models
+ - View game history
+
+4. **Performance Analysis**
+ - Move timing
+ - Strategy tracking
+ - Game statistics
diff --git a/ai_agent_tutorials/ai_tic_tac_toe_agent/agents.py b/ai_agent_tutorials/ai_tic_tac_toe_agent/agents.py
new file mode 100644
index 0000000..6be0dc8
--- /dev/null
+++ b/ai_agent_tutorials/ai_tic_tac_toe_agent/agents.py
@@ -0,0 +1,165 @@
+"""
+Tic Tac Toe Battle
+---------------------------------
+This example shows how to build a Tic Tac Toe game where two AI agents play against each other.
+The game features a referee agent coordinating between two player agents using different
+language models.
+
+Usage Examples:
+---------------
+1. Quick game with default settings:
+ referee_agent = get_tic_tac_toe_referee()
+ play_tic_tac_toe()
+
+2. Game with debug mode off:
+ referee_agent = get_tic_tac_toe_referee(debug_mode=False)
+ play_tic_tac_toe(debug_mode=False)
+
+The game integrates:
+ - Multiple AI models (Claude, GPT-4, etc.)
+ - Turn-based gameplay coordination
+ - Move validation and game state management
+"""
+
+import sys
+from pathlib import Path
+from textwrap import dedent
+from typing import Tuple
+
+from agno.agent import Agent
+from agno.models.anthropic import Claude
+from agno.models.google import Gemini
+from agno.models.groq import Groq
+from agno.models.openai import OpenAIChat
+
+project_root = str(Path(__file__).parent.parent.parent.parent)
+if project_root not in sys.path:
+ sys.path.append(project_root)
+
+
+def get_model_for_provider(provider: str, model_name: str):
+ """
+ Creates and returns the appropriate model instance based on the provider.
+
+ Args:
+ provider: The model provider (e.g., 'openai', 'google', 'anthropic', 'groq')
+ model_name: The specific model name/ID
+
+ Returns:
+ An instance of the appropriate model class
+
+ Raises:
+ ValueError: If the provider is not supported
+ """
+ if provider == "openai":
+ return OpenAIChat(id=model_name)
+ elif provider == "google":
+ return Gemini(id=model_name)
+ elif provider == "anthropic":
+ if model_name == "claude-3-5-sonnet":
+ return Claude(id="claude-3-5-sonnet-20241022", max_tokens=8192)
+ elif model_name == "claude-3-7-sonnet":
+ return Claude(
+ id="claude-3-7-sonnet-20250219",
+ max_tokens=8192,
+ )
+ elif model_name == "claude-3-7-sonnet-thinking":
+ return Claude(
+ id="claude-3-7-sonnet-20250219",
+ max_tokens=8192,
+ thinking={"type": "enabled", "budget_tokens": 4096},
+ )
+ else:
+ return Claude(id=model_name)
+ elif provider == "groq":
+ return Groq(id=model_name)
+ else:
+ raise ValueError(f"Unsupported model provider: {provider}")
+
+
+def get_tic_tac_toe_players(
+ model_x: str = "openai:gpt-4o",
+ model_o: str = "openai:o3-mini",
+ debug_mode: bool = True,
+) -> Tuple[Agent, Agent]:
+ """
+ Returns an instance of the Tic Tac Toe Referee Agent that coordinates the game.
+
+ Args:
+ model_x: ModelConfig for player X
+ model_o: ModelConfig for player O
+ model_referee: ModelConfig for the referee agent
+ debug_mode: Enable logging and debug features
+
+ Returns:
+ An instance of the configured Referee Agent
+ """
+ # Parse model provider and name
+ provider_x, model_name_x = model_x.split(":")
+ provider_o, model_name_o = model_o.split(":")
+
+ # Create model instances using the helper function
+ model_x = get_model_for_provider(provider_x, model_name_x)
+ model_o = get_model_for_provider(provider_o, model_name_o)
+
+ player_x = Agent(
+ name="Player X",
+ description=dedent("""\
+ You are Player X in a Tic Tac Toe game. Your goal is to win by placing three X's in a row (horizontally, vertically, or diagonally).
+
+ BOARD LAYOUT:
+ - The board is a 3x3 grid with coordinates from (0,0) to (2,2)
+ - Top-left is (0,0), bottom-right is (2,2)
+
+ RULES:
+ - You can only place X in empty spaces (shown as " " on the board)
+ - Players take turns placing their marks
+ - First to get 3 marks in a row (horizontal, vertical, or diagonal) wins
+ - If all spaces are filled with no winner, the game is a draw
+
+ YOUR RESPONSE:
+ - Provide ONLY two numbers separated by a space (row column)
+ - Example: "1 2" places your X in row 1, column 2
+ - Choose only from the valid moves list provided to you
+
+ STRATEGY TIPS:
+ - Study the board carefully and make strategic moves
+ - Block your opponent's potential winning moves
+ - Create opportunities for multiple winning paths
+ - Pay attention to the valid moves and avoid illegal moves
+ """),
+ model=model_x,
+ debug_mode=debug_mode,
+ )
+
+ player_o = Agent(
+ name="Player O",
+ description=dedent("""\
+ You are Player O in a Tic Tac Toe game. Your goal is to win by placing three O's in a row (horizontally, vertically, or diagonally).
+
+ BOARD LAYOUT:
+ - The board is a 3x3 grid with coordinates from (0,0) to (2,2)
+ - Top-left is (0,0), bottom-right is (2,2)
+
+ RULES:
+ - You can only place X in empty spaces (shown as " " on the board)
+ - Players take turns placing their marks
+ - First to get 3 marks in a row (horizontal, vertical, or diagonal) wins
+ - If all spaces are filled with no winner, the game is a draw
+
+ YOUR RESPONSE:
+ - Provide ONLY two numbers separated by a space (row column)
+ - Example: "1 2" places your X in row 1, column 2
+ - Choose only from the valid moves list provided to you
+
+ STRATEGY TIPS:
+ - Study the board carefully and make strategic moves
+ - Block your opponent's potential winning moves
+ - Create opportunities for multiple winning paths
+ - Pay attention to the valid moves and avoid illegal moves
+ """),
+ model=model_o,
+ debug_mode=debug_mode,
+ )
+
+ return player_x, player_o
diff --git a/ai_agent_tutorials/ai_tic_tac_toe_agent/app.py b/ai_agent_tutorials/ai_tic_tac_toe_agent/app.py
new file mode 100644
index 0000000..17faeff
--- /dev/null
+++ b/ai_agent_tutorials/ai_tic_tac_toe_agent/app.py
@@ -0,0 +1,261 @@
+import nest_asyncio
+import streamlit as st
+from agents import get_tic_tac_toe_players
+from agno.utils.log import logger
+from utils import (
+ CUSTOM_CSS,
+ TicTacToeBoard,
+ display_board,
+ display_move_history,
+ show_agent_status,
+)
+
+nest_asyncio.apply()
+
+# Page configuration
+st.set_page_config(
+ page_title="Agent Tic Tac Toe",
+ page_icon="๐ฎ",
+ layout="wide",
+ initial_sidebar_state="expanded",
+)
+
+# Load custom CSS with dark mode support
+st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
+
+
+def main():
+ ####################################################################
+ # App header
+ ####################################################################
+ st.markdown(
+ "
+ {create_mini_board_html(board_copy, (row, col), is_player1)}
+
+
Move #{move["number"]}
+
{move["player"]}
+
Position: ({row}, {col})
+
+
'
+
+ # Left column (Player 1)
+ history_content += '
'
+ for i in range(max_moves):
+ entry_html = ""
+ # Player 1 move
+ if i < len(p1_moves):
+ entry_html += p1_moves[i]
+ history_content += entry_html
+ history_content += "
"
+
+ # Right column (Player 2)
+ history_content += '
'
+ for i in range(max_moves):
+ entry_html = ""
+ # Player 2 move
+ if i < len(p2_moves):
+ entry_html += p2_moves[i]
+ history_content += entry_html
+ history_content += "
"
+
+ history_content += "
+ No moves yet. Start the game to see the history!
+
""",
+ unsafe_allow_html=True,
+ )
+
+
+CUSTOM_CSS = """
+
+"""
diff --git a/ai_agent_tutorials/ai_travel_agent/README.MD b/ai_agent_tutorials/ai_travel_agent/README.MD
index 9117ad7..d9b492f 100644
--- a/ai_agent_tutorials/ai_travel_agent/README.MD
+++ b/ai_agent_tutorials/ai_travel_agent/README.MD
@@ -12,6 +12,7 @@ This Streamlit app is an AI-powered travel Agent that generates personalized tra
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/ai_travel_agent
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/ai_travel_agent/local_travel_agent.py b/ai_agent_tutorials/ai_travel_agent/local_travel_agent.py
index fb0b856..e56a91c 100644
--- a/ai_agent_tutorials/ai_travel_agent/local_travel_agent.py
+++ b/ai_agent_tutorials/ai_travel_agent/local_travel_agent.py
@@ -1,21 +1,21 @@
from textwrap import dedent
-from phi.assistant import Assistant
-from phi.tools.serpapi_tools import SerpApiTools
+from agno.agent import Agent
+from agno.tools.serpapi import SerpApiTools
import streamlit as st
-from phi.llm.ollama import Ollama
+from agno.models.ollama import Ollama
# Set up the Streamlit app
-st.title("AI Travel Planner using Llama-3 โ๏ธ")
+st.title("AI Travel Planner using Llama-3.2 โ๏ธ")
st.caption("Plan your next adventure with AI Travel Planner by researching and planning a personalized itinerary on autopilot using local Llama-3")
# Get SerpAPI key from the user
serp_api_key = st.text_input("Enter Serp API Key for Search functionality", type="password")
if serp_api_key:
- researcher = Assistant(
+ researcher = Agent(
name="Researcher",
role="Searches for travel destinations, activities, and accommodations based on user preferences",
- llm=Ollama(model="llama3:instruct", max_tokens=1024),
+ model=Ollama(id="llama3.2", max_tokens=1024),
description=dedent(
"""\
You are a world-class travel researcher. Given a travel destination and the number of days the user wants to travel for,
@@ -32,10 +32,10 @@ if serp_api_key:
tools=[SerpApiTools(api_key=serp_api_key)],
add_datetime_to_instructions=True,
)
- planner = Assistant(
+ planner = Agent(
name="Planner",
role="Generates a draft itinerary based on user preferences and research results",
- llm=Ollama(model="llama3:instruct", max_tokens=1024),
+ model=Ollama(id="llama3.2", max_tokens=1024),
description=dedent(
"""\
You are a senior travel planner. Given a travel destination, the number of days the user wants to travel for, and a list of research results,
@@ -51,8 +51,6 @@ if serp_api_key:
"Never make up facts or plagiarize. Always provide proper attribution.",
],
add_datetime_to_instructions=True,
- add_chat_history_to_prompt=True,
- num_history_messages=3,
)
# Input fields for the user's destination and the number of days they want to travel for
@@ -63,4 +61,4 @@ if serp_api_key:
with st.spinner("Processing..."):
# Get the response from the assistant
response = planner.run(f"{destination} for {num_days} days", stream=False)
- st.write(response)
\ No newline at end of file
+ st.write(response.content)
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_travel_agent/requirements.txt b/ai_agent_tutorials/ai_travel_agent/requirements.txt
index 549573b..ffff278 100644
--- a/ai_agent_tutorials/ai_travel_agent/requirements.txt
+++ b/ai_agent_tutorials/ai_travel_agent/requirements.txt
@@ -1,4 +1,4 @@
streamlit
-phidata
+agno
openai
google-search-results
\ No newline at end of file
diff --git a/ai_agent_tutorials/ai_travel_agent/travel_agent.py b/ai_agent_tutorials/ai_travel_agent/travel_agent.py
index 5a3fee6..eab9bbf 100644
--- a/ai_agent_tutorials/ai_travel_agent/travel_agent.py
+++ b/ai_agent_tutorials/ai_travel_agent/travel_agent.py
@@ -1,8 +1,8 @@
from textwrap import dedent
-from phi.assistant import Assistant
-from phi.tools.serpapi_tools import SerpApiTools
+from agno.agent import Agent
+from agno.tools.serpapi import SerpApiTools
import streamlit as st
-from phi.llm.openai import OpenAIChat
+from agno.models.openai import OpenAIChat
# Set up the Streamlit app
st.title("AI Travel Planner โ๏ธ")
@@ -15,10 +15,10 @@ openai_api_key = st.text_input("Enter OpenAI API Key to access GPT-4o", type="pa
serp_api_key = st.text_input("Enter Serp API Key for Search functionality", type="password")
if openai_api_key and serp_api_key:
- researcher = Assistant(
+ researcher = Agent(
name="Researcher",
role="Searches for travel destinations, activities, and accommodations based on user preferences",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a world-class travel researcher. Given a travel destination and the number of days the user wants to travel for,
@@ -35,10 +35,10 @@ if openai_api_key and serp_api_key:
tools=[SerpApiTools(api_key=serp_api_key)],
add_datetime_to_instructions=True,
)
- planner = Assistant(
+ planner = Agent(
name="Planner",
role="Generates a draft itinerary based on user preferences and research results",
- llm=OpenAIChat(model="gpt-4o", api_key=openai_api_key),
+ model=OpenAIChat(id="gpt-4o", api_key=openai_api_key),
description=dedent(
"""\
You are a senior travel planner. Given a travel destination, the number of days the user wants to travel for, and a list of research results,
@@ -54,8 +54,6 @@ if openai_api_key and serp_api_key:
"Never make up facts or plagiarize. Always provide proper attribution.",
],
add_datetime_to_instructions=True,
- add_chat_history_to_prompt=True,
- num_history_messages=3,
)
# Input fields for the user's destination and the number of days they want to travel for
@@ -63,7 +61,21 @@ if openai_api_key and serp_api_key:
num_days = st.number_input("How many days do you want to travel for?", min_value=1, max_value=30, value=7)
if st.button("Generate Itinerary"):
- with st.spinner("Processing..."):
- # Get the response from the assistant
- response = planner.run(f"{destination} for {num_days} days", stream=False)
- st.write(response)
\ No newline at end of file
+ with st.spinner("Researching your destination..."):
+ # First get research results
+ research_results = researcher.run(f"Research {destination} for a {num_days} day trip", stream=False)
+
+ # Show research progress
+ st.write("โ Research completed")
+
+ with st.spinner("Creating your personalized itinerary..."):
+ # Pass research results to planner
+ prompt = f"""
+ Destination: {destination}
+ Duration: {num_days} days
+ Research Results: {research_results.content}
+
+ Please create a detailed itinerary based on this research.
+ """
+ response = planner.run(prompt, stream=False)
+ st.write(response.content)
\ No newline at end of file
diff --git a/ai_agent_tutorials/gemini_multimodal_agent_demo/multimodal_ai_agent.py b/ai_agent_tutorials/gemini_multimodal_agent_demo/multimodal_ai_agent.py
new file mode 100644
index 0000000..1a6a3cd
--- /dev/null
+++ b/ai_agent_tutorials/gemini_multimodal_agent_demo/multimodal_ai_agent.py
@@ -0,0 +1,33 @@
+from agno.agent import Agent
+from agno.models.google import Gemini
+from agno.tools.duckduckgo import DuckDuckGoTools
+from google.generativeai import upload_file, get_file
+import time
+
+# 1. Initialize the Multimodal Agent
+agent = Agent(model=Gemini(id="gemini-2.0-flash-exp"), tools=[DuckDuckGoTools()], markdown=True)
+
+# 2. Image Input
+image_url = "https://example.com/sample_image.jpg"
+
+# 3. Audio Input
+audio_file = "sample_audio.mp3"
+
+# 4. Video Input
+video_file = upload_file("sample_video.mp4")
+while video_file.state.name == "PROCESSING":
+ time.sleep(2)
+ video_file = get_file(video_file.name)
+
+# 5. Multimodal Query
+query = """
+Combine insights from the inputs:
+1. **Image**: Describe the scene and its significance.
+2. **Audio**: Extract key messages that relate to the visual.
+3. **Video**: Look at the video input and provide insights that connect with the image and audio context.
+4. **Web Search**: Find the latest updates or events linking all these topics.
+Summarize the overall theme or story these inputs convey.
+"""
+
+# 6. Multimodal Agent generates unified response
+agent.print_response(query, images=[image_url], audio=audio_file, videos=[video_file], stream=True)
\ No newline at end of file
diff --git a/ai_agent_tutorials/legal_ai_agent/legal_agent.py b/ai_agent_tutorials/legal_ai_agent/legal_agent.py
deleted file mode 100644
index 7bdb400..0000000
--- a/ai_agent_tutorials/legal_ai_agent/legal_agent.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from phi.agent import Agent
-from phi.model.openai import OpenAIChat
-from phi.knowledge.pdf import PDFKnowledgeBase, PDFReader
-from phi.vectordb.lancedb import LanceDb, SearchType
-from phi.playground import Playground, serve_playground_app
-from phi.tools.duckduckgo import DuckDuckGo
-
-# Set up configurations
-DB_URI = "tmp/legal_docs_db"
-
-# Create a knowledge base for legal documents
-knowledge_base = PDFKnowledgeBase(
- path="tmp/legal_docs",
- vector_db=LanceDb(
- table_name="legal_documents",
- uri=DB_URI,
- search_type=SearchType.vector
- ),
- reader=PDFReader(chunk=True),
- num_documents=5
-)
-
-# Create the agent
-agent = Agent(
- model=OpenAIChat(id="gpt-4"),
- agent_id="legal-analysis-agent",
- knowledge=knowledge_base,
- tools=[DuckDuckGo()],
- show_tool_calls=True,
- markdown=True,
-)
-
-app = Playground(agents=[agent]).get_app()
-
-if __name__ == "__main__":
- serve_playground_app("legal_agent:app", reload=True)
\ No newline at end of file
diff --git a/ai_agent_tutorials/legal_ai_agent/requirements.txt b/ai_agent_tutorials/legal_ai_agent/requirements.txt
deleted file mode 100644
index 53c213c..0000000
--- a/ai_agent_tutorials/legal_ai_agent/requirements.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-streamlit
-phidata
-openai
-lancedb
-tantivy
-pypdf
-duckduckgo-search
\ No newline at end of file
diff --git a/ai_agent_tutorials/local_news_agent_openai_swarm/README.md b/ai_agent_tutorials/local_news_agent_openai_swarm/README.md
index 904f02c..3f460e5 100644
--- a/ai_agent_tutorials/local_news_agent_openai_swarm/README.md
+++ b/ai_agent_tutorials/local_news_agent_openai_swarm/README.md
@@ -18,7 +18,7 @@ This Streamlit application implements a sophisticated news processing pipeline u
1. Clone the GitHub repository
```bash
git clone https://github.com/your-username/ai-news-processor.git
-cd local_news_agent_openai_swarm
+cd awesome-llm-apps/ai_agent_tutorials/local_news_agent_openai_swarm
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/multi_agent_researcher/README.md b/ai_agent_tutorials/multi_agent_researcher/README.md
index 0b81011..d8276e4 100644
--- a/ai_agent_tutorials/multi_agent_researcher/README.md
+++ b/ai_agent_tutorials/multi_agent_researcher/README.md
@@ -12,6 +12,7 @@ This Streamlit app empowers you to research top stories and users on HackerNews
```bash
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd awesome-llm-apps/ai_agent_tutorials/multi_agent_researcher
```
2. Install the required dependencies:
diff --git a/ai_agent_tutorials/multi_agent_researcher/requirements.txt b/ai_agent_tutorials/multi_agent_researcher/requirements.txt
index a0e8efb..c54384d 100644
--- a/ai_agent_tutorials/multi_agent_researcher/requirements.txt
+++ b/ai_agent_tutorials/multi_agent_researcher/requirements.txt
@@ -1,3 +1,3 @@
streamlit
-phidata
+agno
openai
\ No newline at end of file
diff --git a/ai_agent_tutorials/multi_agent_researcher/research_agent.py b/ai_agent_tutorials/multi_agent_researcher/research_agent.py
index a5a6fcb..e1c06dd 100644
--- a/ai_agent_tutorials/multi_agent_researcher/research_agent.py
+++ b/ai_agent_tutorials/multi_agent_researcher/research_agent.py
@@ -1,8 +1,8 @@
# Import the required libraries
import streamlit as st
-from phi.assistant import Assistant
-from phi.tools.hackernews import HackerNews
-from phi.llm.openai import OpenAIChat
+from agno.agent import Agent
+from agno.tools.hackernews import HackerNewsTools
+from agno.models.openai import OpenAIChat
# Set up the Streamlit app
st.title("Multi-Agent AI Researcher ๐๐ค")
@@ -13,23 +13,23 @@ openai_api_key = st.text_input("OpenAI API Key", type="password")
if openai_api_key:
# Create instances of the Assistant
- story_researcher = Assistant(
+ story_researcher = Agent(
name="HackerNews Story Researcher",
role="Researches hackernews stories and users.",
- tools=[HackerNews()],
+ tools=[HackerNewsTools()],
)
- user_researcher = Assistant(
+ user_researcher = Agent(
name="HackerNews User Researcher",
role="Reads articles from URLs.",
- tools=[HackerNews()],
+ tools=[HackerNewsTools()],
)
- hn_assistant = Assistant(
+ hn_assistant = Agent(
name="Hackernews Team",
team=[story_researcher, user_researcher],
- llm=OpenAIChat(
- model="gpt-4o",
+ model=OpenAIChat(
+ id="gpt-4o",
max_tokens=1024,
temperature=0.5,
api_key=openai_api_key
@@ -42,4 +42,4 @@ if openai_api_key:
if query:
# Get the response from the assistant
response = hn_assistant.run(query, stream=False)
- st.write(response)
\ No newline at end of file
+ st.write(response.content)
\ No newline at end of file
diff --git a/ai_agent_tutorials/multi_agent_researcher/research_agent_llama3.py b/ai_agent_tutorials/multi_agent_researcher/research_agent_llama3.py
index 96d55e0..1be2d52 100644
--- a/ai_agent_tutorials/multi_agent_researcher/research_agent_llama3.py
+++ b/ai_agent_tutorials/multi_agent_researcher/research_agent_llama3.py
@@ -1,32 +1,32 @@
# Import the required libraries
import streamlit as st
-from phi.assistant import Assistant
-from phi.tools.hackernews import HackerNews
-from phi.llm.ollama import Ollama
+from agno.agent import Agent
+from agno.tools.hackernews import HackerNews
+from agno.models.ollama import Ollama
# Set up the Streamlit app
st.title("Multi-Agent AI Researcher using Llama-3 ๐๐ค")
st.caption("This app allows you to research top stories and users on HackerNews and write blogs, reports and social posts.")
# Create instances of the Assistant
-story_researcher = Assistant(
+story_researcher = Agent(
name="HackerNews Story Researcher",
role="Researches hackernews stories and users.",
tools=[HackerNews()],
- llm=Ollama(model="llama3:instruct", max_tokens=1024)
+ model=Ollama(id="llama3.2", max_tokens=1024)
)
-user_researcher = Assistant(
+user_researcher = Agent(
name="HackerNews User Researcher",
role="Reads articles from URLs.",
tools=[HackerNews()],
- llm=Ollama(model="llama3:instruct", max_tokens=1024)
+ model=Ollama(id="llama3.2", max_tokens=1024)
)
-hn_assistant = Assistant(
+hn_assistant = Agent(
name="Hackernews Team",
team=[story_researcher, user_researcher],
- llm=Ollama(model="llama3:instruct", max_tokens=1024)
+ model=Ollama(id="llama3.2", max_tokens=1024)
)
# Input field for the report query
@@ -35,4 +35,4 @@ query = st.text_input("Enter your report query")
if query:
# Get the response from the assistant
response = hn_assistant.run(query, stream=False)
- st.write(response)
\ No newline at end of file
+ st.write(response.content)
\ No newline at end of file
diff --git a/ai_agent_tutorials/multimodal_ai_agent/README.md b/ai_agent_tutorials/multimodal_ai_agent/README.md
new file mode 100644
index 0000000..1cb9b4d
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_ai_agent/README.md
@@ -0,0 +1,39 @@
+## ๐งฌ Multimodal AI Agent
+
+A Streamlit application that combines video analysis and web search capabilities using Google's Gemini 2.0 model. This agent can analyze uploaded videos and answer questions by combining visual understanding with web-search.
+
+### Features
+
+- Video analysis using Gemini 2.0 Flash
+- Web research integration via DuckDuckGo
+- Support for multiple video formats (MP4, MOV, AVI)
+- Real-time video processing
+- Combined visual and textual analysis
+
+### How to get Started?
+
+1. Clone the GitHub repository
+
+```bash
+git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+cd ai_agent_tutorials/multimodal_ai_agent
+```
+2. Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+3. Get your Google Gemini API Key
+
+- Sign up for an [Google AI Studio account](https://aistudio.google.com/apikey) and obtain your API key.
+
+4. Set up your Gemini API Key as the environment variable
+
+```bash
+GOOGLE_API_KEY=your_api_key_here
+```
+
+5. Run the Streamlit App
+```bash
+streamlit run multimodal_agent.py
+```
diff --git a/ai_agent_tutorials/multimodal_ai_agent/multimodal_reasoning_agent.py b/ai_agent_tutorials/multimodal_ai_agent/multimodal_reasoning_agent.py
new file mode 100644
index 0000000..428805a
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_ai_agent/multimodal_reasoning_agent.py
@@ -0,0 +1,62 @@
+import streamlit as st
+from agno.agent import Agent
+from agno.models.google import Gemini
+import tempfile
+import os
+
+def main():
+ # Set up the reasoning agent
+ agent = Agent(
+ model=Gemini(id="gemini-2.0-flash-thinking-exp-1219"),
+ markdown=True
+ )
+
+ # Streamlit app title
+ st.title("Multimodal Reasoning AI Agent ๐ง ")
+
+ # Instruction
+ st.write(
+ "Upload an image and provide a reasoning-based task for the AI Agent. "
+ "The AI Agent will analyze the image and respond based on your input."
+ )
+
+ # File uploader for image
+ uploaded_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
+
+ if uploaded_file is not None:
+ try:
+ # Save uploaded file to temporary file
+ with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+ tmp_file.write(uploaded_file.getvalue())
+ temp_path = tmp_file.name
+
+ # Display the uploaded image
+ st.image(uploaded_file, caption="Uploaded Image", use_container_width=True)
+
+ # Input for dynamic task
+ task_input = st.text_area(
+ "Enter your task/question for the AI Agent:"
+ )
+
+ # Button to process the image and task
+ if st.button("Analyze Image") and task_input:
+ with st.spinner("AI is thinking... ๐ค"):
+ try:
+ # Call the agent with the dynamic task and image path
+ response = agent.run(task_input, images=[temp_path])
+
+ # Display the response from the model
+ st.markdown("### AI Response:")
+ st.markdown(response.content)
+ except Exception as e:
+ st.error(f"An error occurred during analysis: {str(e)}")
+ finally:
+ # Clean up temp file
+ if os.path.exists(temp_path):
+ os.unlink(temp_path)
+
+ except Exception as e:
+ st.error(f"An error occurred while processing the image: {str(e)}")
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/ai_agent_tutorials/multimodal_ai_agent/mutimodal_agent.py b/ai_agent_tutorials/multimodal_ai_agent/mutimodal_agent.py
new file mode 100644
index 0000000..23b77c1
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_ai_agent/mutimodal_agent.py
@@ -0,0 +1,83 @@
+import streamlit as st
+from agno.agent import Agent
+from agno.models.google import Gemini
+from agno.media import Video
+import time
+from pathlib import Path
+import tempfile
+
+st.set_page_config(
+ page_title="Multimodal AI Agent",
+ page_icon="๐งฌ",
+ layout="wide"
+)
+
+st.title("Multimodal AI Agent ๐งฌ")
+
+# Get Gemini API key from user
+gemini_api_key = st.text_input("Enter your Gemini API Key", type="password")
+
+# Initialize single agent with both capabilities
+@st.cache_resource
+def initialize_agent(api_key):
+ return Agent(
+ name="Multimodal Analyst",
+ model=Gemini(id="gemini-2.0-flash", api_key=api_key),
+ markdown=True,
+ )
+
+if gemini_api_key:
+ agent = initialize_agent(gemini_api_key)
+
+ # File uploader
+ uploaded_file = st.file_uploader("Upload a video file", type=['mp4', 'mov', 'avi'])
+
+ if uploaded_file:
+ with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
+ tmp_file.write(uploaded_file.read())
+ video_path = tmp_file.name
+
+ st.video(video_path)
+
+ user_prompt = st.text_area(
+ "What would you like to know?",
+ placeholder="Ask any question related to the video - the AI Agent will analyze it and search the web if needed",
+ help="You can ask questions about the video content and get relevant information from the web"
+ )
+
+ if st.button("Analyze & Research"):
+ if not user_prompt:
+ st.warning("Please enter your question.")
+ else:
+ try:
+ with st.spinner("Processing video and researching..."):
+ video = Video(filepath=video_path)
+
+ prompt = f"""
+ First analyze this video and then answer the following question using both
+ the video analysis and web research: {user_prompt}
+
+ Provide a comprehensive response focusing on practical, actionable information.
+ """
+
+ result = agent.run(prompt, videos=[video])
+
+ st.subheader("Result")
+ st.markdown(result.content)
+
+ except Exception as e:
+ st.error(f"An error occurred: {str(e)}")
+ finally:
+ Path(video_path).unlink(missing_ok=True)
+ else:
+ st.info("Please upload a video to begin analysis.")
+else:
+ st.warning("Please enter your Gemini API key to continue.")
+
+st.markdown("""
+
+ """, unsafe_allow_html=True)
\ No newline at end of file
diff --git a/ai_agent_tutorials/multimodal_ai_agent/requirements.txt b/ai_agent_tutorials/multimodal_ai_agent/requirements.txt
new file mode 100644
index 0000000..fad806f
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_ai_agent/requirements.txt
@@ -0,0 +1,3 @@
+agno
+google-generativeai==0.8.3
+streamlit==1.40.2
\ No newline at end of file
diff --git a/ai_agent_tutorials/multimodal_design_agent_team/README.md b/ai_agent_tutorials/multimodal_design_agent_team/README.md
new file mode 100644
index 0000000..cb8e620
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_design_agent_team/README.md
@@ -0,0 +1,69 @@
+# Multimodal AI Design Agent Team
+
+A Streamlit application that provides comprehensive design analysis using a team of specialized AI agents powered by Google's Gemini model.
+
+This application leverages multiple specialized AI agents to provide comprehensive analysis of UI/UX designs of your product and your competitors, combining visual understanding, user experience evaluation, and market research insights.
+
+## Features
+
+- **Specialized Legal AI Agent Team**
+
+ - ๐จ **Visual Design Agent**: Evaluates design elements, patterns, color schemes, typography, and visual hierarchy
+ - ๐ **UX Analysis Agent**: Assesses user flows, interaction patterns, usability, and accessibility
+ - ๐ **Market Analysis Agent**: Provides market insights, competitor analysis, and positioning recommendations
+
+- **Multiple Analysis Types**: Choose from Visual Design, UX, and Market Analysis
+- **Comparative Analysis**: Upload competitor designs for comparative insights
+- **Customizable Focus Areas**: Select specific aspects for detailed analysis
+- **Context-Aware**: Provide additional context for more relevant insights
+- **Real-time Processing**: Get instant analysis with progress indicators
+- **Structured Output**: Receive well-organized, actionable insights
+
+## How to Run
+
+1. **Setup Environment**
+ ```bash
+ # Clone the repository
+ git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
+ cd awesome-llm-apps/ai_agent_tutorials/multimodal_design_agent_team
+
+ # Create and activate virtual environment (optional)
+ python -m venv venv
+ source venv/bin/activate # On Windows: venv\Scripts\activate
+
+ # Install dependencies
+ pip install -r requirements.txt
+ ```
+
+2. **Get API Key**
+ - Visit [Google AI Studio](https://aistudio.google.com/apikey)
+ - Generate an API key
+
+3. **Run the Application**
+ ```bash
+ streamlit run design_agent_team.py
+ ```
+
+4. **Use the Application**
+ - Enter your Gemini API key in the sidebar
+ - Upload design files (supported formats: JPG, JPEG, PNG)
+ - Select analysis types and focus areas
+ - Add context if needed
+ - Click "Run Analysis" to get insights
+
+
+## Technical Stack
+
+- **Frontend**: Streamlit
+- **AI Model**: Google Gemini 2.0
+- **Image Processing**: Pillow
+- **Market Research**: DuckDuckGo Search API
+- **Framework**: Phidata for agent orchestration
+
+## Tips for Best Results
+
+- Upload clear, high-resolution images
+- Include multiple views/screens for better context
+- Add competitor designs for comparative analysis
+- Provide specific context about your target audience
+
diff --git a/ai_agent_tutorials/multimodal_design_agent_team/design_agent_team.py b/ai_agent_tutorials/multimodal_design_agent_team/design_agent_team.py
new file mode 100644
index 0000000..32145d5
--- /dev/null
+++ b/ai_agent_tutorials/multimodal_design_agent_team/design_agent_team.py
@@ -0,0 +1,269 @@
+from agno.agent import Agent
+from agno.models.google import Gemini
+from agno.tools.duckduckgo import DuckDuckGoTools
+import streamlit as st
+from PIL import Image
+from typing import List, Optional
+
+def initialize_agents(api_key: str) -> tuple[Agent, Agent, Agent]:
+ try:
+ model = Gemini(id="gemini-2.0-flash-exp", api_key=api_key)
+
+ vision_agent = Agent(
+ model=model,
+ instructions=[
+ "You are a visual analysis expert that:",
+ "1. Identifies design elements, patterns, and visual hierarchy",
+ "2. Analyzes color schemes, typography, and layouts",
+ "3. Detects UI components and their relationships",
+ "4. Evaluates visual consistency and branding",
+ "Be specific and technical in your analysis"
+ ],
+ markdown=True
+ )
+
+ ux_agent = Agent(
+ model=model,
+ instructions=[
+ "You are a UX analysis expert that:",
+ "1. Evaluates user flows and interaction patterns",
+ "2. Identifies usability issues and opportunities",
+ "3. Suggests UX improvements based on best practices",
+ "4. Analyzes accessibility and inclusive design",
+ "Focus on user-centric insights and practical improvements"
+ ],
+ markdown=True
+ )
+
+ market_agent = Agent(
+ model=model,
+ tools=[DuckDuckGoTools()],
+ instructions=[
+ "You are a market research expert that:",
+ "1. Identifies market trends and competitor patterns",
+ "2. Analyzes similar products and features",
+ "3. Suggests market positioning and opportunities",
+ "4. Provides industry-specific insights",
+ "Focus on actionable market intelligence"
+ ],
+ markdown=True
+ )
+
+ return vision_agent, ux_agent, market_agent
+ except Exception as e:
+ st.error(f"Error initializing agents: {str(e)}")
+ return None, None, None
+
+# Sidebar for API key input
+with st.sidebar:
+ st.header("๐ API Configuration")
+
+ if "api_key_input" not in st.session_state:
+ st.session_state.api_key_input = ""
+
+ api_key = st.text_input(
+ "Enter your Gemini API Key",
+ value=st.session_state.api_key_input,
+ type="password",
+ help="Get your API key from Google AI Studio",
+ key="api_key_widget"
+ )
+
+ if api_key != st.session_state.api_key_input:
+ st.session_state.api_key_input = api_key
+
+ if api_key:
+ st.success("API Key provided! โ
")
+ else:
+ st.warning("Please enter your API key to proceed")
+ st.markdown("""
+ To get your API key:
+ 1. Go to [Google AI Studio](https://makersuite.google.com/app/apikey)
+ """)
+
+st.title("Multimodal AI Design Agent Team")
+
+if st.session_state.api_key_input:
+ vision_agent, ux_agent, market_agent = initialize_agents(st.session_state.api_key_input)
+
+ if all([vision_agent, ux_agent, market_agent]):
+ # File Upload Section
+ st.header("๐ค Upload Content")
+ col1, space, col2 = st.columns([1, 0.1, 1])
+
+ with col1:
+ design_files = st.file_uploader(
+ "Upload UI/UX Designs",
+ type=["jpg", "jpeg", "png"],
+ accept_multiple_files=True,
+ key="designs"
+ )
+
+ if design_files:
+ for file in design_files:
+ image = Image.open(file)
+ st.image(image, caption=file.name, use_container_width=True)
+
+ with col2:
+ competitor_files = st.file_uploader(
+ "Upload Competitor Designs (Optional)",
+ type=["jpg", "jpeg", "png"],
+ accept_multiple_files=True,
+ key="competitors"
+ )
+
+ if competitor_files:
+ for file in competitor_files:
+ image = Image.open(file)
+ st.image(image, caption=f"Competitor: {file.name}", use_container_width=True)
+
+ # Analysis Configuration
+ st.header("๐ฏ Analysis Configuration")
+
+ analysis_types = st.multiselect(
+ "Select Analysis Types",
+ ["Visual Design", "User Experience", "Market Analysis"],
+ default=["Visual Design"]
+ )
+
+ specific_elements = st.multiselect(
+ "Focus Areas",
+ ["Color Scheme", "Typography", "Layout", "Navigation",
+ "Interactions", "Accessibility", "Branding", "Market Fit"]
+ )
+
+ context = st.text_area(
+ "Additional Context",
+ placeholder="Describe your product, target audience, or specific concerns..."
+ )
+
+ # Analysis Process
+ if st.button("๐ Run Analysis", type="primary"):
+ if design_files:
+ try:
+ st.header("๐ Analysis Results")
+
+ # Process images once
+ def process_images(files):
+ processed_images = []
+ for file in files:
+ try:
+ # Create a temporary file path for the image
+ import tempfile
+ import os
+
+ temp_dir = tempfile.gettempdir()
+ temp_path = os.path.join(temp_dir, f"temp_{file.name}")
+
+ # Save the uploaded file to temp location
+ with open(temp_path, "wb") as f:
+ f.write(file.getvalue())
+
+ # Add the path to processed images
+ processed_images.append(temp_path)
+
+ except Exception as e:
+ st.error(f"Error processing image {file.name}: {str(e)}")
+ continue
+ return processed_images
+
+ design_images = process_images(design_files)
+ competitor_images = process_images(competitor_files) if competitor_files else []
+ all_images = design_images + competitor_images
+
+ # Visual Design Analysis
+ if "Visual Design" in analysis_types and design_files:
+ with st.spinner("๐จ Analyzing visual design..."):
+ if all_images:
+ vision_prompt = f"""
+ Analyze these designs focusing on: {', '.join(specific_elements)}
+ Additional context: {context}
+ Provide specific insights about visual design elements.
+
+ Please format your response with clear headers and bullet points.
+ Focus on concrete observations and actionable insights.
+ """
+
+ response = vision_agent.run(
+ message=vision_prompt,
+ images=all_images
+ )
+
+ st.subheader("๐จ Visual Design Analysis")
+ st.markdown(response.content)
+
+ # UX Analysis
+ if "User Experience" in analysis_types:
+ with st.spinner("๐ Analyzing user experience..."):
+ if all_images:
+ ux_prompt = f"""
+ Evaluate the user experience considering: {', '.join(specific_elements)}
+ Additional context: {context}
+ Focus on user flows, interactions, and accessibility.
+
+ Please format your response with clear headers and bullet points.
+ Focus on concrete observations and actionable improvements.
+ """
+
+ response = ux_agent.run(
+ message=ux_prompt,
+ images=all_images
+ )
+
+ st.subheader("๐ UX Analysis")
+ st.markdown(response.content)
+
+ # Market Analysis
+ if "Market Analysis" in analysis_types:
+ with st.spinner("๐ Conducting market analysis..."):
+ market_prompt = f"""
+ Analyze market positioning and trends based on these designs.
+ Context: {context}
+ Compare with competitor designs if provided.
+ Suggest market opportunities and positioning.
+
+ Please format your response with clear headers and bullet points.
+ Focus on concrete market insights and actionable recommendations.
+ """
+
+ response = market_agent.run(
+ message=market_prompt,
+ images=all_images
+ )
+
+ st.subheader("๐ Market Analysis")
+ st.markdown(response.content)
+
+ # Combined Insights
+ if len(analysis_types) > 1:
+ st.subheader("๐ฏ Key Takeaways")
+ st.info("""
+ Above you'll find detailed analysis from multiple specialized AI agents, each focusing on their area of expertise:
+ - Visual Design Agent: Analyzes design elements and patterns
+ - UX Agent: Evaluates user experience and interactions
+ - Market Research Agent: Provides market context and opportunities
+ """)
+
+ except Exception as e:
+ st.error(f"An error occurred during analysis: {str(e)}")
+ st.error("Please check your API key and try again.")
+ else:
+ st.warning("Please upload at least one design to analyze.")
+ else:
+ st.info("๐ Please enter your API key in the sidebar to get started")
+else:
+ st.info("๐ Please enter your API key in the sidebar to get started")
+
+# Footer with usage tips
+st.markdown("---")
+st.markdown("""
+
+
Tips for Best Results
+
+ โข Upload clear, high-resolution images
+ โข Include multiple views/screens for better context
+ โข Add competitor designs for comparative analysis
+ โข Provide specific context about your target audience
+
+
+ 
+
+
+ 
+ 
+