Spaces:
Sleeping
Sleeping
Download src/gaia/tools/__init__.py from jm-vis/Final_Assignment_GAIAAgent: direct link, hf CLI and curl.
- Browser
- Download file 21.7 kB
-
https://huggingface.co/spaces/jm-vis/Final_Assignment_GAIAAgent/resolve/main/src/gaia/tools/__init__.py
- Command line
-
hf download hf://spaces/jm-vis/Final_Assignment_GAIAAgent/src/gaia/tools/__init__.py
-
curl -L -o __init__.py https://huggingface.co/spaces/jm-vis/Final_Assignment_GAIAAgent/resolve/main/src/gaia/tools/__init__.py
21.7 kB
| """ | |
| Tools module for GAIA implementation. | |
| Contains implementations of various tools for web browsing, reasoning, and multimodal processing. | |
| Includes a tool registry for dynamic tool selection based on question requirements. | |
| """ | |
| import logging | |
| from typing import Dict, Any, List, Optional, Union, Callable, Type, Set | |
| # Import locally from this package to avoid circular imports | |
| from src.gaia.tools.web_tools import ( | |
| DuckDuckGoSearchTool, | |
| SerperSearchTool, | |
| WebContentExtractor, | |
| WebNavigator, | |
| create_duckduckgo_search, | |
| create_serper_search, | |
| create_web_content_extractor, | |
| create_web_navigator | |
| ) | |
| from src.gaia.tools.reasoning_tools import ( | |
| StepByStepReasoner, | |
| MathCalculator, | |
| FactVerifier, | |
| create_step_by_step_reasoner, | |
| create_math_calculator, | |
| create_fact_verifier | |
| ) | |
| from src.gaia.tools.perplexity_tool import ( | |
| PerplexityTool, | |
| create_perplexity_tool | |
| ) | |
| from src.gaia.tools.multimodal_tools import ( | |
| ImageAnalyzer, | |
| ChartInterpreter, | |
| DocumentParser, | |
| YouTubeVideoTool, | |
| create_image_analyzer, | |
| create_chart_interpreter, | |
| create_document_parser, | |
| create_youtube_video_tool | |
| ) | |
| logger = logging.getLogger("gaia_agent.tools") | |
| class ToolMetadata: | |
| """Metadata for a tool in the registry.""" | |
| def __init__( | |
| self, | |
| name: str, | |
| description: str, | |
| category: str, | |
| factory: Callable[[], Any], | |
| keywords: List[str], | |
| input_schema: Dict[str, Any], | |
| output_schema: Dict[str, Any], | |
| requires_api_key: bool = False, | |
| example_uses: List[str] = None | |
| ): | |
| """ | |
| Initialize tool metadata. | |
| Args: | |
| name: The name of the tool | |
| description: A description of what the tool does | |
| category: The category of the tool (web, reasoning, multimodal) | |
| factory: A factory function that creates an instance of the tool | |
| keywords: Keywords for tool selection | |
| input_schema: Schema describing the tool's input parameters | |
| output_schema: Schema describing the tool's output format | |
| requires_api_key: Whether the tool requires an API key | |
| example_uses: Example use cases for the tool | |
| """ | |
| self.name = name | |
| self.description = description | |
| self.category = category | |
| self.factory = factory | |
| self.keywords = keywords | |
| self.input_schema = input_schema | |
| self.output_schema = output_schema | |
| self.requires_api_key = requires_api_key | |
| self.example_uses = example_uses or [] | |
| self._instance = None | |
| def get_instance(self) -> Any: | |
| """ | |
| Get or create an instance of the tool. | |
| Returns: | |
| An instance of the tool | |
| """ | |
| if self._instance is None: | |
| self._instance = self.factory() | |
| return self._instance | |
| class ToolRegistry: | |
| """Registry for managing available tools.""" | |
| def __init__(self): | |
| """Initialize the tool registry.""" | |
| self.tools: Dict[str, ToolMetadata] = {} | |
| self.categories: Dict[str, List[str]] = { | |
| "web": [], | |
| "reasoning": [], | |
| "multimodal": [] | |
| } | |
| def register_tool(self, metadata: ToolMetadata) -> None: | |
| """ | |
| Register a tool in the registry. | |
| Args: | |
| metadata: The tool metadata | |
| """ | |
| self.tools[metadata.name] = metadata | |
| if metadata.category in self.categories: | |
| self.categories[metadata.category].append(metadata.name) | |
| else: | |
| self.categories[metadata.category] = [metadata.name] | |
| def get_tool(self, name: str) -> Optional[Any]: | |
| """ | |
| Get a tool instance by name. | |
| Args: | |
| name: The name of the tool | |
| Returns: | |
| The tool instance, or None if not found | |
| """ | |
| if name not in self.tools: | |
| logger.warning(f"Tool not found: {name}") | |
| return None | |
| return self.tools[name].get_instance() | |
| def get_tool_metadata(self, name: str) -> Optional[ToolMetadata]: | |
| """ | |
| Get tool metadata by name. | |
| Args: | |
| name: The name of the tool | |
| Returns: | |
| The tool metadata, or None if not found | |
| """ | |
| return self.tools.get(name) | |
| def list_tools(self, category: Optional[str] = None) -> List[str]: | |
| """ | |
| List available tools, optionally filtered by category. | |
| Args: | |
| category: Optional category to filter by | |
| Returns: | |
| List of tool names | |
| """ | |
| if category: | |
| return self.categories.get(category, []) | |
| return list(self.tools.keys()) | |
| def select_tools(self, requirements: List[str]) -> List[str]: | |
| """ | |
| Select appropriate tools based on requirements. | |
| Args: | |
| requirements: List of tool requirements or keywords | |
| Returns: | |
| List of selected tool names | |
| """ | |
| selected_tools = set() | |
| for req in requirements: | |
| req_lower = req.lower() | |
| if req_lower in self.tools: | |
| selected_tools.add(req_lower) | |
| continue | |
| for name, metadata in self.tools.items(): | |
| if any(keyword.lower() in req_lower for keyword in metadata.keywords): | |
| selected_tools.add(name) | |
| return list(selected_tools) | |
| def get_tools_by_question(self, question: str) -> List[str]: | |
| """ | |
| Select appropriate tools based on a question. | |
| Args: | |
| question: The question to analyze | |
| Returns: | |
| List of selected tool names | |
| """ | |
| question_lower = question.lower() | |
| selected_tools = set() | |
| if any(term in question_lower for term in ["search", "find", "look up", "latest", "current", "news"]): | |
| selected_tools.add("duckduckgo_search") | |
| selected_tools.add("perplexity_search") | |
| if any(term in question_lower for term in ["website", "webpage", "url", "link", "extract", "content"]): | |
| selected_tools.add("web_content_extractor") | |
| if any(term in question_lower for term in ["navigate", "browse", "follow", "links"]): | |
| selected_tools.add("web_navigator") | |
| if any(term in question_lower for term in ["reason", "explain", "why", "how", "analyze"]): | |
| selected_tools.add("step_by_step_reasoner") | |
| selected_tools.add("perplexity_search") | |
| if any(term in question_lower for term in ["calculate", "compute", "solve", "equation", "math", "formula"]): | |
| selected_tools.add("math_calculator") | |
| if any(term in question_lower for term in ["verify", "check", "fact", "true", "false", "accurate"]): | |
| selected_tools.add("fact_verifier") | |
| selected_tools.add("perplexity_search") | |
| if any(term in question_lower for term in ["image", "picture", "photo", "describe", "visual", "see"]): | |
| selected_tools.add("image_analyzer") | |
| if any(term in question_lower for term in ["chart", "graph", "plot", "diagram", "visualization", "trend"]): | |
| selected_tools.add("chart_interpreter") | |
| if any(term in question_lower for term in ["document", "pdf", "docx", "text", "extract", "parse", "read"]): | |
| selected_tools.add("document_parser") | |
| if not selected_tools: | |
| selected_tools.add("step_by_step_reasoner") | |
| selected_tools.add("perplexity_search") | |
| return list(selected_tools) | |
| registry = ToolRegistry() | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="duckduckgo_search", | |
| description="Search the web using DuckDuckGo", | |
| category="web", | |
| factory=create_duckduckgo_search, | |
| keywords=["search", "web", "find", "lookup", "information", "duckduckgo"], | |
| input_schema={ | |
| "query": { | |
| "type": "string", | |
| "description": "The search query" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": { | |
| "title": {"type": "string"}, | |
| "link": {"type": "string"}, | |
| "snippet": {"type": "string"} | |
| } | |
| } | |
| }, | |
| example_uses=[ | |
| "Finding current information about a topic", | |
| "Searching for specific facts or data", | |
| "Looking up definitions or explanations" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="serper_search", | |
| description="Search the web using Serper API", | |
| category="web", | |
| factory=create_serper_search, | |
| keywords=["search", "web", "find", "lookup", "information", "serper", "google"], | |
| input_schema={ | |
| "query": { | |
| "type": "string", | |
| "description": "The search query" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": { | |
| "title": {"type": "string"}, | |
| "link": {"type": "string"}, | |
| "snippet": {"type": "string"} | |
| } | |
| } | |
| }, | |
| requires_api_key=True, | |
| example_uses=[ | |
| "Finding current information about a topic", | |
| "Searching for specific facts or data", | |
| "Looking up definitions or explanations" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="web_content_extractor", | |
| description="Extract content from a web page", | |
| category="web", | |
| factory=create_web_content_extractor, | |
| keywords=["extract", "content", "webpage", "website", "url", "scrape"], | |
| input_schema={ | |
| "url": { | |
| "type": "string", | |
| "description": "The URL to extract content from" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "url": {"type": "string"}, | |
| "title": {"type": "string"}, | |
| "content": {"type": "string"}, | |
| "links": {"type": "array"}, | |
| "metadata": {"type": "object"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Extracting the main content from an article", | |
| "Getting the text content of a webpage", | |
| "Analyzing the structure of a webpage" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="web_navigator", | |
| description="Navigate and scrape web pages", | |
| category="web", | |
| factory=create_web_navigator, | |
| keywords=["navigate", "browse", "follow", "links", "scrape", "crawl"], | |
| input_schema={ | |
| "url": { | |
| "type": "string", | |
| "description": "The URL to navigate to" | |
| }, | |
| "link_pattern": { | |
| "type": "string", | |
| "description": "Optional regex pattern to match links", | |
| "required": False | |
| } | |
| }, | |
| output_schema={ | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": { | |
| "url": {"type": "string"}, | |
| "title": {"type": "string"}, | |
| "content": {"type": "string"}, | |
| "links": {"type": "array"}, | |
| "metadata": {"type": "object"} | |
| } | |
| } | |
| }, | |
| example_uses=[ | |
| "Following links on a webpage", | |
| "Crawling a website for specific information", | |
| "Navigating through multiple pages" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="step_by_step_reasoner", | |
| description="Perform step-by-step reasoning on a question", | |
| category="reasoning", | |
| factory=create_step_by_step_reasoner, | |
| keywords=["reason", "analyze", "step", "logic", "thinking", "solve"], | |
| input_schema={ | |
| "question": { | |
| "type": "string", | |
| "description": "The question to reason about" | |
| }, | |
| "context": { | |
| "type": "string", | |
| "description": "Optional context information", | |
| "required": False | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "steps": { | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": { | |
| "step_number": {"type": "integer"}, | |
| "reasoning": {"type": "string"}, | |
| "intermediate_conclusion": {"type": "string"} | |
| } | |
| } | |
| }, | |
| "final_conclusion": {"type": "string"}, | |
| "confidence": {"type": "number"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Breaking down complex problems", | |
| "Analyzing logical arguments", | |
| "Solving multi-step reasoning tasks" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="math_calculator", | |
| description="Perform mathematical calculations", | |
| category="reasoning", | |
| factory=create_math_calculator, | |
| keywords=["calculate", "compute", "math", "equation", "solve", "formula", "arithmetic"], | |
| input_schema={ | |
| "expression": { | |
| "type": "string", | |
| "description": "The mathematical expression to evaluate" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "expression": {"type": "string"}, | |
| "result": {"type": "number"}, | |
| "steps": {"type": "array"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Evaluating mathematical expressions", | |
| "Solving equations", | |
| "Performing arithmetic calculations" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="fact_verifier", | |
| description="Verify facts and claims", | |
| category="reasoning", | |
| factory=create_fact_verifier, | |
| keywords=["verify", "fact", "check", "claim", "true", "false", "accuracy"], | |
| input_schema={ | |
| "claim": { | |
| "type": "string", | |
| "description": "The claim to verify" | |
| }, | |
| "evidence": { | |
| "type": "string", | |
| "description": "Optional evidence to use for verification", | |
| "required": False | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "is_verifiable": {"type": "boolean"}, | |
| "verification_result": {"type": "string"}, | |
| "confidence": {"type": "number"}, | |
| "reasoning": {"type": "string"}, | |
| "missing_information": {"type": "string"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Checking the accuracy of statements", | |
| "Verifying claims against evidence", | |
| "Determining the reliability of information" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="image_analyzer", | |
| description="Analyze and describe images", | |
| category="multimodal", | |
| factory=create_image_analyzer, | |
| keywords=["image", "picture", "photo", "visual", "analyze", "describe"], | |
| input_schema={ | |
| "image_path": { | |
| "type": "string", | |
| "description": "Path to the image file" | |
| }, | |
| "prompt": { | |
| "type": "string", | |
| "description": "Optional specific prompt for analysis", | |
| "required": False | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "description": {"type": "string"}, | |
| "subjects": {"type": "array"}, | |
| "text_content": {"type": "string"}, | |
| "context": {"type": "string"}, | |
| "tags": {"type": "array"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Describing the content of images", | |
| "Identifying objects in photos", | |
| "Extracting text from images", | |
| "Analyzing visual content" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="chart_interpreter", | |
| description="Interpret charts and graphs", | |
| category="multimodal", | |
| factory=create_chart_interpreter, | |
| keywords=["chart", "graph", "plot", "diagram", "visualization", "interpret"], | |
| input_schema={ | |
| "chart_path": { | |
| "type": "string", | |
| "description": "Path to the chart image file" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "chart_type": {"type": "string"}, | |
| "title": {"type": "string"}, | |
| "axes": {"type": "object"}, | |
| "data_points": {"type": "array"}, | |
| "trends": {"type": "array"}, | |
| "insights": {"type": "string"}, | |
| "confidence": {"type": "number"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Interpreting data visualizations", | |
| "Extracting insights from charts", | |
| "Analyzing trends in graphs", | |
| "Understanding statistical plots" | |
| ] | |
| ) | |
| ) | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="document_parser", | |
| description="Parse and extract information from documents", | |
| category="multimodal", | |
| factory=create_document_parser, | |
| keywords=["document", "pdf", "docx", "text", "extract", "parse"], | |
| input_schema={ | |
| "document_path": { | |
| "type": "string", | |
| "description": "Path to the document file" | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "document_path": {"type": "string"}, | |
| "file_type": {"type": "string"}, | |
| "text_content": {"type": "string"}, | |
| "summary": {"type": "string"}, | |
| "word_count": {"type": "integer"}, | |
| "character_count": {"type": "integer"} | |
| } | |
| }, | |
| example_uses=[ | |
| "Extracting text from PDF documents", | |
| "Parsing Word documents", | |
| "Summarizing document content", | |
| "Extracting structured data from documents" | |
| ] | |
| ) | |
| ) | |
| # Register Perplexity tool | |
| registry.register_tool( | |
| ToolMetadata( | |
| name="perplexity_search", | |
| description="Search the web and get reasoning using Perplexity API", | |
| category="web", | |
| factory=create_perplexity_tool, | |
| keywords=["search", "web", "find", "lookup", "information", "perplexity", "reasoning", "online"], | |
| input_schema={ | |
| "query": { | |
| "type": "string", | |
| "description": "The search query" | |
| }, | |
| "max_tokens": { | |
| "type": "integer", | |
| "description": "Maximum number of tokens in the response", | |
| "required": False | |
| }, | |
| "system_prompt": { | |
| "type": "string", | |
| "description": "Optional system prompt to guide the response", | |
| "required": False | |
| } | |
| }, | |
| output_schema={ | |
| "type": "object", | |
| "properties": { | |
| "query": {"type": "string"}, | |
| "content": {"type": "string"}, | |
| "citations": {"type": "array"}, | |
| "usage": {"type": "object"}, | |
| "model": {"type": "string"} | |
| } | |
| }, | |
| requires_api_key=True, | |
| example_uses=[ | |
| "Searching for current information with reasoning", | |
| "Getting detailed explanations with citations", | |
| "Answering complex questions with web search" | |
| ] | |
| ) | |
| ) | |
| def get_tool(name: str) -> Optional[Any]: | |
| """ | |
| Get a tool instance by name. | |
| Args: | |
| name: The name of the tool | |
| Returns: | |
| The tool instance, or None if not found | |
| """ | |
| return registry.get_tool(name) | |
| def list_tools(category: Optional[str] = None) -> List[str]: | |
| """ | |
| List available tools, optionally filtered by category. | |
| Args: | |
| category: Optional category to filter by | |
| Returns: | |
| List of tool names | |
| """ | |
| return registry.list_tools(category) | |
| def select_tools_for_question(question: str) -> List[str]: | |
| """ | |
| Select appropriate tools based on a question. | |
| Args: | |
| question: The question to analyze | |
| Returns: | |
| List of selected tool names | |
| """ | |
| return registry.get_tools_by_question(question) | |
| def get_tool_metadata(name: str) -> Optional[ToolMetadata]: | |
| """ | |
| Get tool metadata by name. | |
| Args: | |
| name: The name of the tool | |
| Returns: | |
| The tool metadata, or None if not found | |
| """ | |
| return registry.get_tool_metadata(name) |