Initial commit

.gitignore

@@ -0,0 +1,79 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Environment variables and secrets
+local/
+.env
+*.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# UV lock file (optional - uncomment if you want to ignore it)
+# uv.lock
+
+# Temporary files
+*.log
+*.tmp
+*.temp
+message.txt
+debug_agent.py
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+main.py

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -1,12 +1,50 @@
----
-title: Cas Task 1
-emoji: 🐢
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Generative AI Application
+
+This is a simple generative AI application built using OpenAI's GPT model, Gradio for the user interface, and tools for Wikipedia and Tavily web search.
+
+## Features
+- Chat with OpenAI's GPT model.
+- Use Wikipedia for quick information retrieval.
+- Use Tavily for web search.
+
+## Setup Instructions
+
+### Prerequisites
+- Python 3.10 or higher
+- `uv` for package management
+
+### Installation
+   cd CAS_generative_AI
+   ```
+
+2. Copy the `.env.example` file to `.env` and fill in your API keys:
+   ```
+
+3. Install dependencies using `uv`:
+   ```bash
+   uv install
+   ```
+
+### Running the Application
+ This is a simple generative AI application built using OpenAI's GPT model, Gradio for the user interface, and tools for Wikipedia and Tavily web search.
+ **API keys are managed via a `.env` file and loaded automatically using `python-dotenv`.**
+```bash
+python app.py
+```
+
+The app will be available at `http://0.0.0.0:7860`.
+
+## Configuration
+All configurations are stored in `config.yaml`. Update this file to modify settings such as API keys, model parameters, and tool options.
+
+## Tools
+### Wikipedia Tool
+- Retrieves summaries from Wikipedia.
+- Configurable language and number of sentences.
+
+### Tavily Tool
+- Performs web searches using the Tavily API.
+- Configurable search depth and result limits.
+
+## License
+This project is licensed under the MIT License.

agent.py

@@ -0,0 +1,219 @@
+"""
+Generative AI Agent with Tool Calling Capabilities
+
+This module provides an intelligent agent that can use multiple tools (Wikipedia, Tavily)
+to answer user queries with up-to-date and accurate information.
+"""
+
+import os
+import yaml
+import logging
+from dotenv import load_dotenv
+
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import Tool
+from tools.wikipedia_tool import WikipediaTool
+from langchain_tavily import TavilySearch
+from langgraph.prebuilt import create_react_agent
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+class GenerativeAIAgent:
+    """
+    An intelligent agent that uses LangGraph's ReAct pattern to answer queries.
+    
+    The agent can dynamically select and use tools (Wikipedia, Tavily Search) based on
+    the user's query to provide accurate and up-to-date information.
+    
+    Attributes:
+        llm: The language model (ChatOpenAI)
+        tools: List of available tools for the agent
+        agent_executor: The LangGraph ReAct agent executor
+    """
+    
+    def __init__(self, config_path: str = "config.yaml"):
+        """
+        Initialize the GenerativeAIAgent with configuration and tools.
+        
+        Args:
+            config_path: Path to the YAML configuration file
+        """
+        logger.info("Initializing GenerativeAIAgent...")
+        
+        # Load environment variables
+        load_dotenv(dotenv_path="local/.env")
+        
+        # Load configuration
+        self.config = self._load_config(config_path)
+        
+        # Initialize tools
+        self.wikipedia_tool = WikipediaTool(config_path)
+        self.tavily_search = TavilySearch(max_results=5)
+        
+        # Define available tools
+        self.tools = self._initialize_tools()
+        
+        # Initialize language model
+        self.llm = self._initialize_llm()
+        
+        # Create ReAct agent executor
+        self.agent_executor = create_react_agent(self.llm, self.tools)
+        
+        logger.info("Agent initialized successfully with %d tools", len(self.tools))
+    
+    def _load_config(self, config_path: str) -> dict:
+        """Load configuration from YAML file."""
+        try:
+            with open(config_path, "r") as file:
+                config = yaml.safe_load(file)
+                logger.info("Configuration loaded from %s", config_path)
+                return config
+        except FileNotFoundError:
+            logger.error("Config file not found: %s", config_path)
+            raise
+        except yaml.YAMLError as e:
+            logger.error("Error parsing config file: %s", e)
+            raise
+    
+    def _initialize_tools(self) -> list:
+        """Initialize and return the list of tools available to the agent."""
+        tools = [
+            Tool(
+                name="Wikipedia",
+                description=(
+                    "Search Wikipedia for factual, encyclopedic information. "
+                    "Best for: historical facts, scientific concepts, biographies, "
+                    "general knowledge. Input should be a clear search query."
+                ),
+                func=self.wikipedia_tool.search
+            ),
+            Tool(
+                name="Tavily",
+                description=(
+                    "Search the web for current information and latest news. "
+                    "Best for: recent events, breaking news, current trends, "
+                    "real-time data. Input should be a search query."
+                ),
+                func=self.tavily_search.invoke
+            )
+        ]
+        logger.info("Initialized tools: %s", [tool.name for tool in tools])
+        return tools
+    
+    def _initialize_llm(self) -> ChatOpenAI:
+        """Initialize the language model with configuration."""
+        model_config = self.config.get("openai", {})
+        
+        llm = ChatOpenAI(
+            model=model_config.get("model", "gpt-5"),
+            temperature=model_config.get("temperature", 0.7),
+            max_tokens=model_config.get("max_tokens", 1000),
+            api_key=os.getenv("OPENAI_API_KEY")
+        )
+        
+        logger.info("LLM initialized: %s", model_config.get("model"))
+        return llm
+
+    
+    def generate_response(self, user_input: str) -> str:
+        """
+        Generate a response to the user's input using the agent.
+        
+        The agent will automatically select and use appropriate tools based on the query,
+        following the ReAct (Reasoning + Acting) pattern.
+        
+        Args:
+            user_input: The user's question or query
+            
+        Returns:
+            str: The agent's response
+        """
+        if not user_input or not user_input.strip():
+            logger.warning("Empty input received")
+            return "Please provide a valid question or query."
+        
+        try:
+            logger.info("Processing query: %s", user_input[:50] + "..." if len(user_input) > 50 else user_input)
+            
+            # Get system prompt from config
+            system_prompt = self.config.get("app", {}).get(
+                "system_prompt",
+                "You are a helpful AI assistant with access to Wikipedia and web search tools."
+            )
+            
+            # Prepare messages for the agent
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_input}
+            ]
+            
+            # Invoke the agent executor
+            response = self.agent_executor.invoke({"messages": messages})
+            
+            # Extract the final answer from the response
+            final_answer = self._extract_final_answer(response)
+            
+            logger.info("Response generated successfully")
+            return final_answer
+            
+        except Exception as e:
+            logger.error("Error generating response: %s", str(e), exc_info=True)
+            return self._format_error_message(str(e))
+    
+    def _extract_final_answer(self, response: dict) -> str:
+        """
+        Extract the final answer from the agent's response.
+        
+        Args:
+            response: The response dictionary from the agent executor
+            
+        Returns:
+            str: The extracted final answer
+        """
+        if isinstance(response, dict) and "messages" in response:
+            # Iterate through messages in reverse to find the last AI message with content
+            for msg in reversed(response["messages"]):
+                if hasattr(msg, "content") and msg.content and msg.content.strip():
+                    return msg.content.strip()
+        
+        # Fallback
+        logger.warning("Could not extract proper answer from response")
+        return "I apologize, but I couldn't generate a proper response. Please try rephrasing your question."
+    
+    def _format_error_message(self, error: str) -> str:
+        """
+        Format error messages in a user-friendly way.
+        
+        Args:
+            error: The error message
+            
+        Returns:
+            str: A formatted error message
+        """
+        if "rate limit" in error.lower():
+            return "⚠️ Rate limit reached. Please wait a moment and try again."
+        elif "api key" in error.lower():
+            return "⚠️ API authentication error. Please check your API keys."
+        elif "timeout" in error.lower():
+            return "⚠️ Request timed out. Please try again."
+        else:
+            return f"⚠️ An error occurred: {error}\n\nPlease try rephrasing your question or try again later."
+    
+    def get_available_tools(self) -> list:
+        """
+        Get a list of available tools and their descriptions.
+        
+        Returns:
+            list: List of dictionaries containing tool information
+        """
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description
+            }
+            for tool in self.tools
+        ]

app.py

@@ -0,0 +1,126 @@
+
+import gradio as gr
+import os
+from agent import GenerativeAIAgent
+
+
+# Initialize the agent
+agent = GenerativeAIAgent()
+
+
+def chat_with_agent(user_input, history):
+    """Chat function that maintains conversation history"""
+    if not user_input.strip():
+        return history, history
+    
+    response = agent.generate_response(user_input)
+    history.append((user_input, response))
+    return history, history
+
+# Create fancy Gradio interface with custom theme
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="indigo",
+        neutral_hue="slate",
+    ),
+    css="""
+        .gradio-container {
+            font-family: 'Inter', sans-serif;
+        }
+        .chat-container {
+            border-radius: 15px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        footer {
+            display: none !important;
+        }
+    """
+) as demo:
+    gr.Markdown(
+        """
+        # 🤖 AI Assistant with Tool Integration
+        
+        **Powered by GPT-4o-mini** • Ask anything and I'll use Wikipedia or web search to find accurate answers!
+        
+        ---
+        """,
+        elem_classes="header"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown(
+                """
+                ### 🛠️ Available Tools
+                
+                - 📚 **Wikipedia**: For factual information
+                - 🌐 **Tavily Search**: For latest news & web content
+                
+                ### 💡 Try asking:
+                - "What's the latest news about AI?"
+                - "Tell me about quantum computing"
+                - "Recent developments in climate change"
+                """,
+                elem_classes="sidebar"
+            )
+        
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                height=500,
+                bubble_full_width=False,
+                avatar_images=(None, "assistant_avatar.png"),
+                elem_classes="chat-container"
+            )
+            
+            with gr.Row():
+                user_input = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type your question here... 💬",
+                    lines=2,
+                    scale=4
+                )
+                submit_btn = gr.Button("Send 🚀", variant="primary", scale=1)
+            
+            with gr.Row():
+                clear_btn = gr.Button("Clear Chat 🗑️", variant="secondary")
+            
+            # Store conversation history
+            state = gr.State([])
+            
+            # Event handlers
+            submit_btn.click(
+                fn=chat_with_agent,
+                inputs=[user_input, state],
+                outputs=[chatbot, state]
+            ).then(
+                lambda: "",
+                outputs=[user_input]
+            )
+            
+            user_input.submit(
+                fn=chat_with_agent,
+                inputs=[user_input, state],
+                outputs=[chatbot, state]
+            ).then(
+                lambda: "",
+                outputs=[user_input]
+            )
+            
+            clear_btn.click(
+                lambda: ([], []),
+                outputs=[chatbot, state]
+            )
+
+    gr.Markdown(
+        """
+        ---
+        
+        🔒 **Privacy**: Your conversations are not stored • ⚡ **Fast**: Powered by OpenAI's latest models
+        """,
+        elem_classes="footer"
+    )
+
+# Launch the app
+demo.launch(share=False)

config.yaml

@@ -0,0 +1,33 @@
+# Configuration for Generative AI Application
+# All API keys and parameters are externalized following Configuration-Driven Architecture
+
+# OpenAI Configuration
+openai:
+  api_key: "${OPENAI_API_KEY}"  # Set via environment variable
+  model: "gpt-4o-mini"
+  temperature: 0.7
+  max_tokens: 1000
+
+# Tavily Search Configuration
+tavily:
+  api_key: "${TAVILY_API_KEY}"  # Set via environment variable
+  max_results: 5
+  search_depth: "basic"  # Options: basic, advanced
+
+# Wikipedia Configuration
+wikipedia:
+  language: "en"
+  sentences: 3
+  auto_suggest: true
+
+# Gradio Configuration
+gradio:
+  server_name: "0.0.0.0"
+  server_port: 7860
+  share: false
+  show_api: false
+
+# Application Settings
+app:
+  system_prompt: "You are a helpful AI assistant with access to Wikipedia and web search tools. Use these tools when you need current information or facts to answer user questions."
+  max_conversation_history: 10

pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "cas-generative-ai"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gradio>=5.49.1",
+    "langchain>=1.0.2",
+    "langchain-community>=0.4",
+    "langchain-core>=1.0.1",
+    "langchain-openai>=1.0.1",
+    "langchain-tavily>=0.2.12",
+    "openai>=2.6.1",
+    "python-dotenv>=1.1.1",
+    "pyyaml>=6.0.3",
+    "tavily-python>=0.7.12",
+    "wikipedia>=1.4.0",
+]

tools/tavily_tool.py

@@ -0,0 +1,29 @@
+import requests
+import yaml
+import os
+from dotenv import load_dotenv
+
+class TavilyTool:
+    def __init__(self, config_path="config.yaml"):
+        load_dotenv()
+        with open(config_path, "r") as file:
+            config = yaml.safe_load(file)
+            self.max_results = config["tavily"]["max_results"]
+            self.search_depth = config["tavily"]["search_depth"]
+        self.api_key = os.getenv("TAVILY_API_KEY")
+
+    def search(self, query):
+        url = "https://api.tavily.com/search"
+        params = {
+            "query": query,
+            "max_results": self.max_results,
+            "depth": self.search_depth
+        }
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        try:
+            response = requests.get(url, params=params, headers=headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return f"An error occurred: {str(e)}"

tools/wikipedia_tool.py

@@ -0,0 +1,23 @@
+import wikipedia
+import yaml
+
+class WikipediaTool:
+    def __init__(self, config_path="config.yaml"):
+        with open(config_path, "r") as file:
+            config = yaml.safe_load(file)
+            self.language = config["wikipedia"]["language"]
+            self.sentences = config["wikipedia"]["sentences"]
+            self.auto_suggest = config["wikipedia"]["auto_suggest"]
+
+        wikipedia.set_lang(self.language)
+
+    def search(self, query):
+        try:
+            summary = wikipedia.summary(query, sentences=self.sentences, auto_suggest=self.auto_suggest)
+            return summary
+        except wikipedia.exceptions.DisambiguationError as e:
+            return f"Disambiguation error: {e.options}"
+        except wikipedia.exceptions.PageError:
+            return "Page not found."
+        except Exception as e:
+            return f"An error occurred: {str(e)}"