pip install gradio langchain openai serper-dev python-doten

import os
import gradio as gr
import traceback
import datetime
from typing import List, Tuple, Optional

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.agents import initialize_agent, AgentType
from langchain.tools import BaseTool
import json
import requests
import dotenv

# Load environment variables
dotenv.load_dotenv()

# ----------- SERPER SEARCH TOOL ------------

class SerperSearchTool(BaseTool):
 name: str = "search_web"
 description: str = "Searches the web for real-time information and returns structured results"

 def _run(self, query: str) -> str:
 """Search the web using Serper API"""
 try:
 api_key = os.getenv("SERPER_API_KEY")
 if not api_key:
 return "Error: SERPER_API_KEY not found in environment variables"

 url = "https://google.serper.dev/search"
 payload = json.dumps({"q": query})
 headers = {
 'X-API-KEY': api_key,
 'Content-Type': 'application/json'
 }

 response = requests.post(url, headers=headers, data=payload, timeout=10)
 response.raise_for_status()
 search_results = response.json()

 # Extract and format organic results
 results = []
 if 'organic' in search_results:
 for item in search_results['organic'][:5]: # Limit to top 5 results
 results.append({
 "title": item.get('title', ''),
 "link": item.get('link', ''),
 "snippet": item.get('snippet', '')
 })

 # Format results in a readable way
 if results:
 formatted_results = "Search Results:\n\n"
 for i, result in enumerate(results, 1):
 formatted_results += f"{i}. {result['title']}\n"
 formatted_results += f" {result['snippet']}\n"
 formatted_results += f" URL: {result['link']}\n\n"
 return formatted_results
 else:
 return "No search results found."

 except requests.exceptions.RequestException as e:
 return f"Error performing search - Network issue: {str(e)}"
 except Exception as e:
 return f"Error performing search: {str(e)}"

 async def _arun(self, query: str) -> str:
 """Async version of search"""
 return self._run(query)

Required Data Fields (in order):

Fitness goal (weight loss, muscle gain, etc.)
Age (in range 10-100 validation)
Gender (male/female/other)
Weight (in units, - kg/lbs)
Height (in cm or feet/inches)
Activity Level (5 predefined levels)
Diet Preferences (vegetarian, vegan, etc.)
Diet Restrictions/allergy
Workout-Preferencing & limitations

# ----------- USER DATA TRACKER CLASS ------------

class UserDataTracker:
 def __init__(self):
 self.data = {}
 # Define required fields with their validation functions and question prompts
 self.required_fields = {
 'fitness_goal': {
 'question': "What is your primary fitness goal? (e.g., weight loss, muscle gain, general fitness)",
 'validate': self._validate_fitness_goal
 },
 'age': {
 'question': "How old are you? (Must be between 10-100)",
 'validate': self._validate_age
 },
 'gender': {
 'question': "What is your gender? (male/female/other)",
 'validate': self._validate_gender
 },
 'weight': {
 'question': "What is your current weight? (e.g., 150 lbs or 68 kg)",
 'validate': self._validate_weight
 },
 'height': {
 'question': "What is your height? (e.g., 5'10\" or 178 cm)",
 'validate': self._validate_height
 },
 'activity_level': {
 'question': "What is your activity level? (sedentary, lightly active, moderately active, very active, extremely active)",
 'validate': self._validate_activity_level
 },
 'dietary_preferences': {
 'question': "Do you follow any specific diet? (e.g., vegetarian, vegan, keto, none)",
 'validate': self._validate_dietary_preferences
 },
 'dietary_restrictions': {
 'question': "Any food allergies or dietary restrictions? (e.g., nuts, dairy, gluten, none)",
 'validate': self._validate_dietary_restrictions
 },
 'workout_preferences': {
 'question': "What are your workout preferences? (e.g., gym, home workouts, equipment available, any injuries?)",
 'validate': self._validate_workout_preferences
 },

 }
 self.current_step = 0

# ----------- LANGCHAIN AGENT SETUP ------------

def initialize_fitcoach_agent():
 """Initialize the FitCoach agent with error handling"""
 try:
 # Check for OpenAI API key
 openai_key = os.getenv("OPENAI_API_KEY")
 if not openai_key:
 raise ValueError("OPENAI_API_KEY not found in environment variables")

 # Initialize the language model with correct model name
 llm = ChatOpenAI(
 model="gpt-4o-mini",
 temperature=0.3,
 openai_api_key=openai_key
 )

 # Initialize tools
 tools = []
 try:
 if os.getenv("SERPER_API_KEY"):
 search_tool = SerperSearchTool()
 tools.append(search_tool)
 print("? Search tool initialized successfully")
 else:
 print("?? SERPER_API_KEY not found - search functionality will be limited")
 except Exception as e:
 print(f"?? Could not initialize search tool: {e}")

 # Initialize memory
 memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

----------- GRADIO CHATBOT LOGIC ------------

def is_plan_content(text: str) -> bool:
 """Check if the text contains a fitness plan with detailed content"""
 if not text or len(text.strip()) < 100: # Too short to be a complete plan
 return False

 # Check for common plan indicators
 plan_indicators = [
 'workout plan', 'exercise routine', 'training program',
 'meal plan', 'nutrition plan', 'diet plan', 'weekly schedule',
 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
 'sets x reps', 'rest between sets', 'warm up', 'cool down',
 'day 1', 'day 2', 'day 3', 'day 4', 'day 5', 'day 6', 'day 7',
 'breakfast', 'lunch', 'dinner', 'snacks', 'meals', 'nutrition',
 'exercise', 'workout', 'training', 'routine', 'program', 'plan'
 ]

 # Check for multiple indicators to reduce false positives
 text_lower = text.lower()
 matching_indicators = [ind for ind in plan_indicators if ind in text_lower]

 # Require at least 3 matching indicators to consider it a plan
 return len(matching_indicators) >= 3