fix the app

Gradio_UI.py

@@ -0,0 +1,92 @@
+import gradio as gr
+from typing import Optional
+import os
+from fastapi.responses import RedirectResponse
+
+class GradioUI:
+    """A Gradio interface that serves as a frontend for the agent API"""
+
+    def __init__(self, agent=None, file_upload_folder: str = None):
+        self.agent = agent
+        self.file_upload_folder = file_upload_folder
+        
+        if self.file_upload_folder is not None:
+            if not os.path.exists(file_upload_folder):
+                os.makedirs(file_upload_folder, exist_ok=True)
+
+    def create_interface(self):
+        with gr.Blocks(css="""
+            #main-container {
+                display: flex;
+                height: 100%;
+            }
+            #menu-column {
+                min-height: 600px;
+                border-right: 1px solid #ddd;
+            }
+            #chat-column {
+                min-height: 600px;
+                flex-grow: 1;
+            }
+            .button-container {
+                padding: 10px;
+            }
+        """) as interface:
+            with gr.Row(elem_id="main-container"):
+                # Left menu strip (1/4 width)
+                with gr.Column(scale=1, elem_id="menu-column"):
+                    gr.Markdown("# Menu")
+                    with gr.Group(elem_classes="button-container"):
+                        new_chat_btn = gr.Button("New Chat", variant="primary")
+                    
+                    # Output area for button actions
+                    menu_output = gr.HTML(label="Action Result")
+                
+                # Right chat console (3/4 width)
+                with gr.Column(scale=3, elem_id="chat-column"):
+                    gr.Markdown("# AI Assistant")
+                    chatbot = gr.Chatbot(
+                        height=500,
+                        type='messages'
+                    )
+                    msg = gr.Textbox(
+                        placeholder="Ask me anything...",
+                        show_label=False,
+                        container=False
+                    )
+                    clear = gr.Button("Clear")
+
+            def handle_new_chat():
+                return None, "Started new conversation"
+
+            def user_input(message, history):
+                try:
+                    response = self.agent.invoke({
+                        "input": message
+                    })
+                    # Update to new message format
+                    history.append({"role": "user", "content": message})
+                    history.append({"role": "assistant", "content": response["output"]})
+                    return "", history
+                except Exception as e:
+                    history.append({"role": "user", "content": message})
+                    history.append({"role": "assistant", "content": f"Error: {str(e)}"})
+                    return "", history
+
+            # Set up event handlers
+            msg.submit(user_input, [msg, chatbot], [msg, chatbot])
+            clear.click(lambda: None, None, chatbot, queue=False)
+            new_chat_btn.click(
+                fn=handle_new_chat,
+                inputs=[],
+                outputs=[chatbot, menu_output]
+            )
+
+        return interface
+
+    def launch(self, **kwargs):
+        """Launch the Gradio interface standalone (for development)"""
+        interface = self.create_interface()
+        interface.launch(**kwargs)
+
+__all__ = ["GradioUI"] 

README.md

@@ -17,109 +17,118 @@ tags:
   - coaching
 ---
 
-# Career Coach Agent 🤖
+# Career Coach AI Assistant
 
-An AI-powered career coaching assistant built with FastAPI, Gradio UI, LangChain, and SmolaGents. This application provides an interactive interface for career guidance through both a REST API and a web-based UI.
+A FastAPI and Gradio-based AI assistant that helps users with career development, powered by Mixtral-8x7B-Instruct and LangChain.
 
-## 🚀 Features
+## Features
 
-- **Unified Interface**: Combined FastAPI and Gradio UI on a single port (7860)
-- **AI-Powered Responses**: Utilizing Mixtral-8x7B-Instruct-v0.1 model
-- **Interactive Chat Interface**: Real-time conversation with the AI agent
-- **Multi-tool Integration**: Including webpage visits and time zone conversions
-- **ReAct Agent Pattern**: Step-by-step reasoning and tool usage
+- Interactive chat interface built with Gradio
+- Career-focused AI assistant using Mixtral-8x7B-Instruct model
+- FastAPI backend with RESTful endpoints
+- LangChain integration for advanced prompt handling and tool usage
+- System prompts and templates managed through YAML configuration
 
-## 🛠️ Technical Stack
+## Project Structure
 
-- **Backend Framework**: FastAPI (mounted with Gradio)
-- **UI Framework**: Gradio with SmolaGents
-- **AI Framework**: 
-  - LangChain ReAct Agent (Backend) - For structured reasoning and tool usage
-  - SmolaGents (UI) - For enhanced agent interactions and chat interface
-- **ML Models**: Hugging Face (Mixtral-8x7B-Instruct-v0.1)
-- **Additional Key Libraries**:
-  - `uvicorn`: ASGI server
-  - `markdownify`: Web content processing
-  - `langchain`: AI framework and tools
-  - `smolagents`: UI agent framework
+```
+career-coach-agent/
+├── app.py              # Main FastAPI application with agent setup
+├── Gradio_UI.py        # Gradio interface implementation
+├── prompts.yaml        # System prompts and templates
+├── main.py            # Application entry point
+└── README.md          # This file
+```
 
-## 📋 Prerequisites
+## Requirements
 
-- Python 3.8+
-- Hugging Face account (for model access)
+- Python 3.12+
+- FastAPI
+- Gradio
+- LangChain
+- Hugging Face Hub API token
 
-## ⚙️ Installation
+## Environment Variables
 
-1. Clone the repository:
+Required environment variables:
 ```bash
-git clone https://github.com/nangelov/career-coach-agent.git
-cd career-coach-agent
+HUGGINGFACEHUB_API_TOKEN=your_huggingface_token
 ```
 
-2. Create and activate a virtual environment:
-```bash
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-```
+## Installation
 
-3. Install dependencies:
+1. Clone the repository:
 ```bash
-pip install -r requirements.txt
+git clone <repository-url>
+cd career-coach-agent
 ```
 
-4. (Required) Set up Hugging Face token:
+2. Install dependencies:
 ```bash
-export HUGGINGFACEHUB_API_TOKEN=your_token_here
+pip install fastapi gradio langchain langchain_huggingface pydantic python-multipart uvicorn
 ```
 
-5. Run the application:
+3. Set up your Hugging Face API token as an environment variable.
+
+## Running the Application
+
+Start the application:
 ```bash
-python main.py
+uvicorn main:app --reload
 ```
 
 The application will be available at:
-- Main UI: http://localhost:7860
-- API Documentation: http://localhost:7860/docs/
-
-## 🌐 Hugging Face Spaces Deployment
-
-This application is specifically designed to work with Hugging Face Spaces:
-- Uses a single port (7860) as required by Spaces
-- Combines FastAPI and Gradio on the same port
-- API documentation is accessible at `/docs/` on the same port
-- All functionality works within Spaces' constraints
-
-## 📚 API Documentation
-
-The API documentation is available at `/docs/` on the same port as the main application (7860). This unified setup ensures compatibility with Hugging Face Spaces while maintaining all functionality.
-
-## 🔑 Key Endpoints
+- Web Interface: http://localhost:8000
+- API Documentation: http://localhost:8000/docs
+- Alternative API Documentation: http://localhost:8000/redoc
+
+## API Endpoints
+
+### `/agent/query` (POST)
+Submit queries to the AI assistant.
+
+Request body:
+```json
+{
+    "query": "string",
+    "thread_id": "string (optional)",
+    "context": {} (optional)
+}
+```
 
-All endpoints are available on port 7860:
-- `/`: Main Gradio UI
-- `/docs/`: API Documentation
-- `/agent/query`: Send queries to the AI agent
+## Features
 
-## 🔍 How It Works
+### AI Assistant
+- Career planning and goal setting
+- Professional development advice
+- Job search strategies
+- Skill development recommendations
+- Industry insights and trends
 
-The application uses a ReAct (Reasoning and Acting) agent pattern, which follows this structure:
-1. **Thought**: The agent reasons about what to do
-2. **Action**: The agent decides which tool to use
-3. **Observation**: The tool returns a result
-4. **Thought**: The agent reasons about the observation
-5. **Action**: The agent either uses another tool or provides a final answer
+### Technical Features
+- Real-time chat interface
+- Timezone-aware responses
+- Session management
+- Error handling
+- CORS support
+- Interactive documentation
 
-## ⚠️ Important Notes
+## Architecture
 
-- The application requires active internet connection for AI model access
-- Hugging Face API token is required for model access
-- All services run on port 7860 to comply with Hugging Face Spaces requirements
-- The UI and API are served from the same port for better integration
+- **FastAPI**: Handles HTTP requests and API endpoints
+- **Gradio**: Provides the web interface
+- **LangChain**: Manages the AI agent and tools
+- **Mixtral-8x7B-Instruct**: Powers the AI responses
+- **YAML Configuration**: Manages system prompts and templates
 
-## 🤝 Contributing
+## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
 
-## 📄 License
+## License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+[Add your license here]

UI.py

@@ -1,278 +0,0 @@
-import os
-import re
-from typing import Optional, List, Dict, Any, Callable
-
-from smolagents.agent_types import AgentAudio, AgentImage, AgentText, handle_agent_output_types
-from smolagents.agents import ActionStep, MultiStepAgent
-from smolagents.memory import MemoryStep
-from smolagents.utils import _is_package_available
-import gradio as gr
-import requests
-
-
-def pull_messages_from_step(
-    step_log: MemoryStep,
-):
-    """Extract ChatMessage objects from agent steps with proper nesting"""
-    if isinstance(step_log, ActionStep):
-        # Output the step number
-        step_number = f"Step {step_log.step_number}" if step_log.step_number is not None else ""
-        yield gr.ChatMessage(role="assistant", content=f"**{step_number}**")
-
-        # First yield the thought/reasoning from the LLM
-        if hasattr(step_log, "model_output") and step_log.model_output is not None:
-            # Clean up the LLM output
-            model_output = step_log.model_output.strip()
-            # Remove any trailing <end_code> and extra backticks, handling multiple possible formats
-            model_output = re.sub(r"```\s*<end_code>", "```", model_output)  # handles ```<end_code>
-            model_output = re.sub(r"<end_code>\s*```", "```", model_output)  # handles <end_code>```
-            model_output = re.sub(r"```\s*\n\s*<end_code>", "```", model_output)  # handles ```\n<end_code>
-            model_output = model_output.strip()
-            yield gr.ChatMessage(role="assistant", content=model_output)
-
-        # For tool calls, create a parent message
-        if hasattr(step_log, "tool_calls") and step_log.tool_calls is not None:
-            first_tool_call = step_log.tool_calls[0]
-            used_code = first_tool_call.name == "python_interpreter"
-            parent_id = f"call_{len(step_log.tool_calls)}"
-
-            # Tool call becomes the parent message with timing info
-            # First we will handle arguments based on type
-            args = first_tool_call.arguments
-            if isinstance(args, dict):
-                content = str(args.get("answer", str(args)))
-            else:
-                content = str(args).strip()
-
-            if used_code:
-                # Clean up the content by removing any end code tags
-                content = re.sub(r"```.*?\n", "", content)  # Remove existing code blocks
-                content = re.sub(r"\s*<end_code>\s*", "", content)  # Remove end_code tags
-                content = content.strip()
-                if not content.startswith("```python"):
-                    content = f"```python\n{content}\n```"
-
-            parent_message_tool = gr.ChatMessage(
-                role="assistant",
-                content=content,
-                metadata={
-                    "title": f"🛠️ Used tool {first_tool_call.name}",
-                    "id": parent_id,
-                    "status": "pending",
-                },
-            )
-            yield parent_message_tool
-
-            # Nesting execution logs under the tool call if they exist
-            if hasattr(step_log, "observations") and (
-                step_log.observations is not None and step_log.observations.strip()
-            ):  # Only yield execution logs if there's actual content
-                log_content = step_log.observations.strip()
-                if log_content:
-                    log_content = re.sub(r"^Execution logs:\s*", "", log_content)
-                    yield gr.ChatMessage(
-                        role="assistant",
-                        content=f"{log_content}",
-                        metadata={"title": "📝 Execution Logs", "parent_id": parent_id, "status": "done"},
-                    )
-
-            # Nesting any errors under the tool call
-            if hasattr(step_log, "error") and step_log.error is not None:
-                yield gr.ChatMessage(
-                    role="assistant",
-                    content=str(step_log.error),
-                    metadata={"title": "💥 Error", "parent_id": parent_id, "status": "done"},
-                )
-
-            # Update parent message metadata to done status without yielding a new message
-            parent_message_tool.metadata["status"] = "done"
-
-        # Handle standalone errors but not from tool calls
-        elif hasattr(step_log, "error") and step_log.error is not None:
-            yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error"})
-
-        # Calculate duration and token information
-        step_footnote = f"{step_number}"
-        if hasattr(step_log, "input_token_count") and hasattr(step_log, "output_token_count"):
-            token_str = (
-                f" | Input-tokens:{step_log.input_token_count:,} | Output-tokens:{step_log.output_token_count:,}"
-            )
-            step_footnote += token_str
-        if hasattr(step_log, "duration"):
-            step_duration = f" | Duration: {round(float(step_log.duration), 2)}" if step_log.duration else None
-            step_footnote += step_duration
-        step_footnote = f"""<span style="color: #bbbbc2; font-size: 12px;">{step_footnote}</span> """
-        yield gr.ChatMessage(role="assistant", content=f"{step_footnote}")
-        yield gr.ChatMessage(role="assistant", content="-----")
-
-
-def stream_to_gradio(
-    agent,
-    task: str,
-    reset_agent_memory: bool = False,
-    additional_args: Optional[dict] = None,
-):
-    """Runs an agent with the given task and streams the messages from the agent as gradio ChatMessages."""
-    if not _is_package_available("gradio"):
-        raise ModuleNotFoundError(
-            "Please install 'gradio' extra to use the AgentUI: `pip install 'smolagents[gradio]'`"
-        )
-
-    total_input_tokens = 0
-    total_output_tokens = 0
-
-    for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
-        # Track tokens if model provides them
-        if hasattr(agent.model, "last_input_token_count"):
-            total_input_tokens += agent.model.last_input_token_count
-            total_output_tokens += agent.model.last_output_token_count
-            if isinstance(step_log, ActionStep):
-                step_log.input_token_count = agent.model.last_input_token_count
-                step_log.output_token_count = agent.model.last_output_token_count
-
-        for message in pull_messages_from_step(
-            step_log,
-        ):
-            yield message
-
-    final_answer = step_log  # Last log is the run's final_answer
-    final_answer = handle_agent_output_types(final_answer)
-
-    if isinstance(final_answer, AgentText):
-        yield gr.ChatMessage(
-            role="assistant",
-            content=f"**Final answer:**\n{final_answer.to_string()}\n",
-        )
-    elif isinstance(final_answer, AgentImage):
-        yield gr.ChatMessage(
-            role="assistant",
-            content={"path": final_answer.to_string(), "mime_type": "image/png"},
-        )
-    elif isinstance(final_answer, AgentAudio):
-        yield gr.ChatMessage(
-            role="assistant",
-            content={"path": final_answer.to_string(), "mime_type": "audio/wav"},
-        )
-    else:
-        yield gr.ChatMessage(role="assistant", content=f"**Final answer:** {str(final_answer)}")
-
-
-class AgentUI:
-    """A Gradio interface that serves as a frontend for the agent API"""
-
-    def __init__(self, agent=None, file_upload_folder: str = None, api_url: str = "http://localhost:8080"):
-        self.agent = agent
-        self.file_upload_folder = file_upload_folder
-        self.api_url = api_url
-        self.thread_id = None
-        
-        if self.file_upload_folder is not None:
-            if not os.path.exists(file_upload_folder):
-                os.makedirs(file_upload_folder, exist_ok=True)
-        
-        self.chat_history = []
-    
-    def query_agent(self, message: str, history: List[List[str]]):
-        """Send a query to the agent API and return the response"""
-        if not message:
-            return "", history
-        
-        try:
-            # Prepare request payload matching QueryRequest model
-            payload = {
-                "query": message,
-                "thread_id": self.thread_id,
-                "context": {}
-            }
-            
-            response = requests.post(
-                f"{self.api_url}/agent/query",
-                json=payload
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                # Update thread_id from response
-                self.thread_id = data.get("thread_id")
-                return "", history + [[message, data["response"]]]
-            else:
-                return "", history + [[message, f"Error: {response.status_code}"]]
-        except Exception as e:
-            return "", history + [[message, f"Error: {str(e)}"]]
-    
-    def reset_conversation(self):
-        """Reset the conversation state"""
-        self.thread_id = None
-        self.chat_history = []
-        return "Started new conversation"
-    
-    def get_gradio_app(self):
-        """Get the Gradio app for mounting in FastAPI"""
-        api_port = int(self.api_url.split(":")[-1])
-        
-        with gr.Blocks(css="""
-            #main-container {
-                display: flex;
-                height: 100%;
-            }
-            #menu-column {
-                min-height: 600px;
-                border-right: 1px solid #ddd;
-            }
-            #chat-column {
-                min-height: 600px;
-            }
-            .button-container {
-                padding: 10px;
-            }
-            .gr-button.green-btn {
-                background-color: #22c55e !important;
-                color: white !important;
-                border: none !important;
-                font-weight: bold;
-            }
-        """) as interface:
-            with gr.Row(elem_id="main-container"):
-                # Left menu strip (1/4 width)
-                with gr.Column(scale=1, elem_id="menu-column"):
-                    gr.Markdown("# Menu")
-                    with gr.Group(elem_classes="button-container"):
-                        docs_btn = gr.Button("API Documentation", variant="secondary", elem_classes=["green-btn"])
-                        new_chat_btn = gr.Button("New Chat", variant="primary")
-                    
-                    # Output area for button actions
-                    menu_output = gr.HTML(label="Action Result")
-                
-                # Right chat console (3/4 width)
-                with gr.Column(scale=3, elem_id="chat-column"):
-                    gr.Markdown("# AI Assistant")
-                    chatbot = gr.Chatbot(height=500)
-                    msg = gr.Textbox(
-                        placeholder="Ask me anything...",
-                        show_label=False,
-                        container=False
-                    )
-                    clear = gr.Button("Clear")
-            
-            # Set up event handlers
-            msg.submit(self.query_agent, [msg, chatbot], [msg, chatbot])
-            clear.click(lambda: ([], None), outputs=[chatbot, menu_output])
-            new_chat_btn.click(
-                fn=lambda: ([], self.reset_conversation()),
-                inputs=[],
-                outputs=[chatbot, menu_output]
-            )
-            docs_btn.click(
-                fn=lambda: f"<script>window.open('/docs', '_blank')</script>",
-                inputs=[],
-                outputs=[menu_output]
-            )
-        
-        return interface
-
-    def launch(self, server_name: str = "0.0.0.0", server_port: int = 7860, **kwargs):
-        """Launch the Gradio interface standalone (for development)"""
-        interface = self.get_gradio_app()
-        interface.launch(server_name=server_name, server_port=server_port, **kwargs)
-
-__all__ = ["stream_to_gradio", "AgentUI"]

app.py

@@ -4,22 +4,19 @@ from langchain.agents import AgentExecutor, create_react_agent
 from langchain_core.prompts import PromptTemplate
 
 from tools.visit_webpage import visit_webpage
-from tools.final_answer import final_answer
+from tools.time_tools import get_current_time
 
-import gradio as gr
-import datetime 
-import pytz
 import os
 import yaml
-import json
 import uuid
-from typing import Optional, Type, Dict, Any, List
+from typing import Optional, Dict, Any
 from pydantic import BaseModel, Field
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, RedirectResponse
-import requests
+import gradio as gr
+
+from Gradio_UI import GradioUI
 
 # Initialize FastAPI app
 app = FastAPI(title="AI Assistant", description="AI Assistant with LangChain and Gradio")
@@ -48,30 +45,22 @@ llm = HuggingFaceEndpoint(
     do_sample=True,
     return_full_text=False,
     model_kwargs={
-        "stop": ["Human:", "Assistant:", "Observation:"]  # Reduced to 3 stop sequences
+        "stop": ["Human:", "Assistant:", "Observation:"]
     }
 )
 
-# Define tools
-@tool
-def get_current_time(timezone: str = "UTC") -> str:
-    """Get the current time in the specified timezone."""
-    try:
-        tz = pytz.timezone(timezone)
-        current_time = datetime.datetime.now(tz)
-        return current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
-    except Exception as e:
-        return f"Error: {str(e)}"
-
 # Load system prompt and template
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
-# Create the ReAct prompt template
-prompt = PromptTemplate.from_template(prompt_templates["template"])
+# Create the ReAct prompt template with system prompt as a partial variable
+prompt = PromptTemplate.from_template(
+    template=prompt_templates["template"],
+    partial_variables={"system_prompt": prompt_templates["system_prompt"]}
+)
 
 # Create the agent
-tools = [get_current_time]  
+tools = [get_current_time, visit_webpage]  
 agent = create_react_agent(
     llm=llm,
     tools=tools,
@@ -91,26 +80,13 @@ class QueryRequest(BaseModel):
     context: Dict[str, Any] = Field(default_factory=dict)
 
 # API Routes
-@app.get("/")
-async def root():
-    return HTMLResponse("<h2>Welcome! Please use the Gradio UI above.</h2>")
-
-@app.get("/docs", include_in_schema=False)
-async def redirect_to_docs():
-    return RedirectResponse(url="/docs/")
-
 @app.post("/agent/query")
 async def query_agent(request: QueryRequest):
     try:
-        # Generate thread_id if not provided
         thread_id = request.thread_id or str(uuid.uuid4())
-        
-        # Execute the agent
         response = agent_executor.invoke({
-            "input": request.query,
-            "system_prompt": prompt_templates["system_prompt"]
+            "input": request.query
         })
-        
         return {
             "status": "success",
             "thread_id": thread_id,
@@ -119,3 +95,7 @@ async def query_agent(request: QueryRequest):
     except Exception as e:
         print(e)
         raise HTTPException(status_code=500, detail=str(e))
+
+# Create and mount the Gradio interface
+gradio_ui = GradioUI(agent=agent_executor)
+app = gr.mount_gradio_app(app, gradio_ui.create_interface(), path="")

main.py

@@ -1,24 +1,15 @@
 import uvicorn
-from app import app, agent
-from UI import AgentUI
+from app import app
 
 def main():
     """
-    Run FastAPI and Gradio UI on the same port
+    Run the FastAPI server with integrated Gradio UI
     """
-    # Configuration
     port = 7860
+    host = "0.0.0.0"
     
-    # Create and mount Gradio app
-    gradio_ui = AgentUI(
-        agent=agent,
-        api_url=f"http://localhost:{port}"
-    )
-    app.mount("/", gradio_ui.get_gradio_app())
-    
-    # Start the combined app
-    print(f"Starting combined server on port {port}...")
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    print(f"Starting server on {host}:{port}...")
+    uvicorn.run(app, host=host, port=port)
 
 if __name__ == "__main__":
     main() 

requirements.txt

@@ -3,7 +3,7 @@ smolagents
 requests>=2.31.0
 fastapi>=0.104.1
 uvicorn[standard]>=0.24.0
-gradio>=4.7.1
+gradio
 langchain>=0.1.0
 langchain-core>=0.1.0
 langchain-community>=0.0.13

tools/__init__.py

@@ -0,0 +1,4 @@
+from .time_tools import get_current_time
+from .visit_webpage import visit_webpage
+
+__all__ = ["get_current_time", "visit_webpage"] 

tools/final_answer.py

@@ -1,14 +0,0 @@
-from langchain_core.tools import tool
-from typing import Any
-
-@tool
-def final_answer(answer: Any) -> Any:
-    """Provides a final answer to the given problem.
-    
-    Args:
-        answer: The final answer to the problem
-        
-    Returns:
-        The final answer unchanged
-    """
-    return answer

tools/time_tools.py

@@ -0,0 +1,13 @@
+from langchain_core.tools import tool
+import datetime
+import pytz
+
+@tool
+def get_current_time(timezone: str = "UTC") -> str:
+    """Get the current time in the specified timezone."""
+    try:
+        tz = pytz.timezone(timezone)
+        current_time = datetime.datetime.now(tz)
+        return current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
+    except Exception as e:
+        return f"Error: {str(e)}"