from langchain.tools import tool
import requests
import json
import math

@tool
def web_search(query: str) -> str:
    """Search the web for information on a given query.
    
    Args:
        query: The search query string
        
    Returns:
        A string containing search results
    """
    # This is a mock implementation - in a real app, you would use a 
    # search API like Google Custom Search, Bing, or DuckDuckGo
    return f"Mock search results for: {query}\n1. Result 1 about {query}\n2. Result 2 about {query}"

@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression.
    
    Args:
        expression: The mathematical expression to evaluate
        
    Returns:
        The result of the calculation
    """
    try:
        # Using eval can be dangerous, but this is just for demonstration
        # In production, use a safer alternative like numexpr
        return str(eval(expression))
    except Exception as e:
        return f"Error calculating: {str(e)}"

@tool
def summarize_text(text: str, max_length: int = 100) -> str:
    """Summarize a piece of text.
    
    Args:
        text: The text to summarize
        max_length: The maximum length of the summary in words
        
    Returns:
        A summarized version of the text
    """
    # This would typically be implemented with an LLM API call
    # Here we're just doing a simple truncation for demonstration
    words = text.split()
    if len(words) <= max_length:
        return text
    return " ".join(words[:max_length]) + "..."

# Export the tools list for agent use
tools_list = [web_search, calculate, summarize_text]

import requests
import json
import math
from typing import Dict, Any

# Define tool schemas for Anthropic's Tool Use API
tools_definitions = [
    {
        "name": "web_search",
        "description": "Search the web for information on a given query",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query string"
                }
            },
            "required": ["query"]
        }
    },
    {
        "name": "calculate",
        "description": "Evaluate a mathematical expression",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string", 
                    "description": "The mathematical expression to evaluate"
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "summarize_text",
        "description": "Summarize a piece of text",
        "input_schema": {
            "type": "object",
            "properties": {
                "text": {
                    "type": "string",
                    "description": "The text to summarize"
                },
                "max_length": {
                    "type": "integer",
                    "description": "The maximum length of the summary in words",
                    "default": 100
                }
            },
            "required": ["text"]
        }
    }
]

# Tool implementations
def web_search(query: str) -> str:
    """Search the web for information on a given query."""
    # This is a mock implementation - in a real app, you would use a 
    # search API like Google Custom Search, Bing, or DuckDuckGo
    return f"Mock search results for: {query}\n1. Result 1 about {query}\n2. Result 2 about {query}"

def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    try:
        # Using eval can be dangerous, but this is just for demonstration
        # In production, use a safer alternative like numexpr
        return str(eval(expression))
    except Exception as e:
        return f"Error calculating: {str(e)}"

def summarize_text(text: str, max_length: int = 100) -> str:
    """Summarize a piece of text."""
    # This would typically be implemented with an LLM API call
    # Here we're just doing a simple truncation for demonstration
    words = text.split()
    if len(words) <= max_length:
        return text
    return " ".join(words[:max_length]) + "..."

# Function to execute tools based on tool call from Anthropic API
def execute_tool(tool_name: str, tool_params: Dict[str, Any]) -> str:
    """Execute the specified tool with the given parameters."""
    if tool_name == "web_search":
        return web_search(tool_params["query"])
    elif tool_name == "calculate":
        return calculate(tool_params["expression"])
    elif tool_name == "summarize_text":
        max_length = tool_params.get("max_length", 100)
        return summarize_text(tool_params["text"], max_length)
    else:
        return f"Tool {tool_name} not found"

from langchain.memory import ConversationBufferMemory
from langchain.schema import HumanMessage, AIMessage

class AgentMemory:
    def __init__(self):
        self.memory = ConversationBufferMemory(return_messages=True)
    
    def add_user_message(self, message: str):
        """Add a user message to memory."""
        self.memory.chat_memory.add_user_message(message)
    
    def add_ai_message(self, message: str):
        """Add an AI message to memory."""
        self.memory.chat_memory.add_ai_message(message)
    
    def get_chat_history(self) -> str:
        """Return chat history as a formatted string."""
        messages = self.memory.chat_memory.messages
        history = ""
        
        for message in messages:
            if isinstance(message, HumanMessage):
                history += f"Human: {message.content}\n"
            elif isinstance(message, AIMessage):
                history += f"AI: {message.content}\n"
        
        return history
    
    def clear(self):
        """Clear the memory."""
        self.memory.chat_memory.clear()

from typing import List, Dict, Any

class Message:
    def __init__(self, role: str, content: str):
        self.role = role
        self.content = content
    
    def to_dict(self) -> Dict[str, str]:
        return {
            "role": self.role, 
            "content": content
        }

class AgentMemory:
    def __init__(self):
        self.messages: List[Dict[str, str]] = []
    
    def add_user_message(self, message: str):
        """Add a user message to memory."""
        self.messages.append({"role": "user", "content": message})
    
    def add_ai_message(self, message: str):
        """Add an AI message to memory."""
        self.messages.append({"role": "assistant", "content": message})
    
    def get_messages(self) -> List[Dict[str, str]]:
        """Return all messages in the format required by Anthropic's API."""
        return self.messages
    
    def get_chat_history(self) -> str:
        """Return chat history as a formatted string."""
        history = ""
        
        for message in self.messages:
            if message["role"] == "user":
                history += f"Human: {message['content']}\n"
            elif message["role"] == "assistant":
                history += f"AI: {message['content']}\n"
        
        return history
    
    def clear(self):
        """Clear the memory."""
        self.messages = []

from langchain.prompts import ChatPromptTemplate

RESEARCH_AGENT_PROMPT = ChatPromptTemplate.from_template("""
You are an advanced AI research assistant designed to help users find and analyze information.
You have access to several tools that you can use to assist users:

1. web_search: Search the web for up-to-date information
2. calculate: Perform mathematical calculations
3. summarize_text: Summarize long pieces of text

When responding to user questions:
1. Think step-by-step about what information is needed
2. Use the appropriate tools to gather necessary information
3. Provide comprehensive, accurate answers with appropriate detail
4. Cite your sources when you provide information from searches

Previous conversation history:
{chat_history}

Current User: {input}

Remember to use tools when necessary to answer the user's question accurately.
""")

SYSTEM_PROMPT = """You are an advanced AI research assistant designed to help users find and analyze information.
You have access to several tools that you can use to assist users.
Always think step-by-step and use the appropriate tools when needed to provide accurate information."""

# Define the system prompt for the research assistant agent
SYSTEM_PROMPT = """You are an advanced AI research assistant designed to help users find and analyze information.
You have access to several tools that you can use to assist users:

1. web_search: Search the web for up-to-date information
2. calculate: Perform mathematical calculations
3. summarize_text: Summarize long pieces of text

When responding to user questions:
1. Think step-by-step about what information is needed
2. Use the appropriate tools to gather necessary information
3. Provide comprehensive, accurate answers with appropriate detail
4. Cite your sources when you provide information from searches
"""

def format_chat_history(chat_history: str) -> str:
    """Format chat history to be included in the prompt."""
    if not chat_history:
        return "No previous conversation."
    
    return f"""Previous conversation history:
{chat_history}"""

import os
from langchain.chains import create_structured_output_runnable
from langchain.chat_models import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.schema import HumanMessage

from tools import tools_list
from memory import AgentMemory
from prompts import RESEARCH_AGENT_PROMPT, SYSTEM_PROMPT

class ResearchAgent:
    def __init__(self, model_name=None):
        # Load API key from environment
        api_key = os.getenv("OPENAI_API_KEY")
        if not api_key:
            raise ValueError("OPENAI_API_KEY not found in environment variables")
        
        # Set model name
        self.model_name = model_name or os.getenv("DEFAULT_MODEL", "gpt-4-turbo")
        
        # Initialize LLM
        self.llm = ChatOpenAI(
            model=self.model_name,
            temperature=0.2,
            api_key=api_key
        )
        
        # Initialize memory
        self.memory = AgentMemory()
        
        # Initialize agent with tools
        self.agent_executor = create_tool_calling_agent(
            llm=self.llm,
            tools=tools_list,
            prompt=RESEARCH_AGENT_PROMPT,
            system_message=SYSTEM_PROMPT
        )
        
        self.executor = AgentExecutor(
            agent=self.agent_executor,
            tools=tools_list,
            verbose=True
        )
    
    async def process_query(self, query: str) -> str:
        """Process a user query and return the agent's response."""
        # Add user query to memory
        self.memory.add_user_message(query)
        
        # Get chat history for context
        chat_history = self.memory.get_chat_history()
        
        # Execute agent with the query and chat history
        response = await self.executor.invoke({
            "input": query,
            "chat_history": chat_history
        })
        
        # Extract response
        output = response["output"]
        
        # Add agent response to memory
        self.memory.add_ai_message(output)
        
        return output

import os
import json
import requests
from typing import Dict, Any, List

from tools import tools_definitions, execute_tool
from memory import AgentMemory
from prompts import SYSTEM_PROMPT, format_chat_history

class ResearchAgent:
    def __init__(self, model_name=None):
        # Load API key from environment
        self.api_key = os.getenv("ANTHROPIC_API_KEY")
        if not self.api_key:
            raise ValueError("ANTHROPIC_API_KEY not found in environment variables")
        
        # Set model name
        self.model_name = model_name or os.getenv("DEFAULT_MODEL", "claude-3-opus-20240229")
        
        # Initialize memory
        self.memory = AgentMemory()
        
        # API constants
        self.api_url = "https://api.anthropic.com/v1/messages"
        self.headers = {
            "Content-Type": "application/json",
            "x-api-key": self.api_key,
            "anthropic-version": "2023-06-01"
        }
    
    async def process_query(self, query: str) -> str:
        """Process a user query and return the agent's response."""
        # Add user query to memory
        self.memory.add_user_message(query)
        
        # Get chat history
        chat_history = self.memory.get_chat_history()
        formatted_history = format_chat_history(chat_history)
        
        # Create message payload
        messages = self.memory.get_messages()
        
        # Create API request data
        request_data = {
            "model": self.model_name,
            "max_tokens": 1024,
            "temperature": 0.2,
            "system": SYSTEM_PROMPT + "\n\n" + formatted_history,
            "messages": messages,
            "tools": tools_definitions
        }
        
        # Make initial API call
        response = requests.post(
            self.api_url, 
            headers=self.headers,
            json=request_data
        )
        
        if response.status_code != 200:
            return f"Error: {response.status_code} - {response.text}"
        
        response_data = response.json()
        
        # Check if the model wants to use tools
        content = response_data["content"]
        final_response = ""
        
        # Process any tool calls
        if response_data.get("tool_calls"):
            # Handle tool calls and create a follow-up message
            tool_calls = response_data["tool_calls"]
            tool_results = []
            
            for tool_call in tool_calls:
                tool_name = tool_call["name"]
                tool_params = json.loads(tool_call["input"])
                tool_result = execute_tool(tool_name, tool_params)
                tool_results.append({
                    "role": "tool",
                    "tool_call_id": tool_call["id"],
                    "name": tool_name,
                    "content": tool_result
                })
            
            # Add tool responses to messages
            messages.extend(tool_results)
            
            # Make a follow-up API call with tool results
            follow_up_request = {
                "model": self.model_name,
                "max_tokens": 1024,
                "temperature": 0.2,
                "system": SYSTEM_PROMPT,
                "messages": messages
            }
            
            follow_up_response = requests.post(
                self.api_url, 
                headers=self.headers,
                json=follow_up_request
            )
            
            if follow_up_response.status_code != 200:
                return f"Error in follow-up: {follow_up_response.status_code} - {follow_up_response.text}"
            
            follow_up_data = follow_up_response.json()
            final_response = follow_up_data["content"][0]["text"]
        else:
            # If no tool calls, use the direct response
            final_response = content[0]["text"]
        
        # Add agent response to memory
        self.memory.add_ai_message(final_response)
        
        return final_response

import os
import asyncio
from dotenv import load_dotenv
from agent import ResearchAgent

# Load environment variables
load_dotenv()

async def main():
    print("Starting Research Assistant Agent (LangChain version)...")
    
    # Initialize the agent
    agent = ResearchAgent()
    
    print("\nResearch Assistant is ready! Type 'exit' to quit.\n")
    
    while True:
        # Get user input
        user_input = input("You: ")
        
        # Exit condition
        if user_input.lower() in ["exit", "quit", "bye"]:
            print("Goodbye!")
            break
        
        try:
            # Process the query with LangChain agent
            response = await agent.process_query(user_input)
            print(f"\nAssistant: {response}\n")
        except Exception as e:
            print(f"Error processing with LangChain agent: {str(e)}")

if __name__ == "__main__":
    # Run the main function
    asyncio.run(main())

import os
import asyncio
from dotenv import load_dotenv
from agent import ResearchAgent

# Load environment variables
load_dotenv()

async def main():
    print("Starting Research Assistant Agent (Anthropic Claude version)...")
    
    try:
        # Initialize the Anthropic-based agent
        agent = ResearchAgent()
        
        print("\nResearch Assistant is ready! Type 'exit' to quit.\n")
        
        while True:
            # Get user input
            user_input = input("You: ")
            
            # Exit condition
            if user_input.lower() in ["exit", "quit", "bye"]:
                print("Goodbye!")
                break
            
            try:
                # Process the query with Anthropic-based agent
                response = await agent.process_query(user_input)
                print(f"\nAssistant: {response}\n")
            except Exception as e:
                print(f"Error in Claude API request: {str(e)}")
    except ValueError as e:
        # Handle missing API key error
        print(f"Configuration error: {str(e)}")
        print("Please make sure ANTHROPIC_API_KEY is set in your .env file")

if __name__ == "__main__":
    # Run the main function
    asyncio.run(main())