praisonaiagents 0.0.22__tar.gz → 0.0.24__tar.gz

{praisonaiagents-0.0.22 → praisonaiagents-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonaiagents
-Version: 0.0.22
+Version: 0.0.24
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.22 → praisonaiagents-0.0.24}/praisonaiagents/agent/agent.py

@@ -394,7 +394,7 @@ Your Goal: {self.goal}
             display_error(f"Error in chat completion: {e}")
             return None
 
-    def chat(self, prompt, temperature=0.2, tools=None, output_json=None):
+    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
         if self.use_system_prompt:
             system_prompt = f"""{self.backstory}\n
 Your Role: {self.role}\n
@@ -402,6 +402,8 @@ Your Goal: {self.goal}
             """
             if output_json:
                 system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
+            elif output_pydantic:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
         else:
             system_prompt = None
 
@@ -410,9 +412,9 @@ Your Goal: {self.goal}
             messages.append({"role": "system", "content": system_prompt})
         messages.extend(self.chat_history)
 
-        # Modify prompt if output_json is specified
+        # Modify prompt if output_json or output_pydantic is specified
         original_prompt = prompt
-        if output_json:
+        if output_json or output_pydantic:
             if isinstance(prompt, str):
                 prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
             elif isinstance(prompt, list):
@@ -487,23 +489,15 @@ Your Goal: {self.goal}
                         return None
                     response_text = response.choices[0].message.content.strip()
 
-                # Handle output_json if specified
-                if output_json:
-                    try:
-                        # Clean the response text to get only JSON
-                        cleaned_json = self.clean_json_output(response_text)
-                        # Parse into Pydantic model
-                        parsed_model = output_json.model_validate_json(cleaned_json)
-                        # Add to chat history and return
-                        self.chat_history.append({"role": "user", "content": original_prompt})
-                        self.chat_history.append({"role": "assistant", "content": response_text})
-                        if self.verbose:
-                            display_interaction(original_prompt, response_text, markdown=self.markdown, 
-                                             generation_time=time.time() - start_time, console=self.console)
-                        return parsed_model
-                    except Exception as e:
-                        display_error(f"Failed to parse response as {output_json.__name__}: {e}")
-                        return None
+                # Handle output_json or output_pydantic if specified
+                if output_json or output_pydantic:
+                    # Add to chat history and return raw response
+                    self.chat_history.append({"role": "user", "content": original_prompt})
+                    self.chat_history.append({"role": "assistant", "content": response_text})
+                    if self.verbose:
+                        display_interaction(original_prompt, response_text, markdown=self.markdown, 
+                                         generation_time=time.time() - start_time, console=self.console)
+                    return response_text
 
                 if not self.self_reflect:
                     self.chat_history.append({"role": "user", "content": original_prompt})
@@ -585,19 +579,21 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             cleaned = cleaned[:-3].strip()
         return cleaned 
 
-    async def achat(self, prompt, temperature=0.2, tools=None, output_json=None):
+    async def achat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
         """Async version of chat method"""
         try:
             # Build system prompt
             system_prompt = self.system_prompt
             if output_json:
                 system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
+            elif output_pydantic:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
 
             # Build messages
             if isinstance(prompt, str):
                 messages = [
                     {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt + ("\nReturn ONLY a valid JSON object. No other text or explanation." if output_json else "")}
+                    {"role": "user", "content": prompt + ("\nReturn ONLY a valid JSON object. No other text or explanation." if (output_json or output_pydantic) else "")}
                 ]
             else:
                 # For multimodal prompts
@@ -605,7 +601,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": prompt}
                 ]
-                if output_json:
+                if output_json or output_pydantic:
                     # Add JSON instruction to text content
                     for item in messages[-1]["content"]:
                         if item["type"] == "text":
@@ -639,22 +635,15 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     tools=formatted_tools
                 )
                 return await self._achat_completion(response, tools)
-            elif output_json:
+            elif output_json or output_pydantic:
                 response = await async_client.chat.completions.create(
                     model=self.llm,
                     messages=messages,
                     temperature=temperature,
                     response_format={"type": "json_object"}
                 )
-                result = response.choices[0].message.content
-                # Clean and parse the JSON response
-                cleaned_json = self.clean_json_output(result)
-                try:
-                    parsed = json.loads(cleaned_json)
-                    return output_json(**parsed)
-                except Exception as e:
-                    display_error(f"Error parsing JSON response: {e}")
-                    return None
+                # Return the raw response
+                return response.choices[0].message.content
             else:
                 response = await async_client.chat.completions.create(
                     model=self.llm,

{praisonaiagents-0.0.22 → praisonaiagents-0.0.24}/praisonaiagents/agents/agents.py

@@ -195,10 +195,17 @@ Here are the results of previous tasks that might be useful:\n
 
             agent_output = await executor_agent.achat(
                 _get_multimodal_message(task_prompt, task.images),
-                tools=task.tools
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
             )
         else:
-            agent_output = await executor_agent.achat(task_prompt, tools=task.tools)
+            agent_output = await executor_agent.achat(
+                task_prompt,
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
 
         if agent_output:
             task_output = TaskOutput(
@@ -405,10 +412,17 @@ Here are the results of previous tasks that might be useful:\n
 
             agent_output = executor_agent.chat(
                 _get_multimodal_message(task_prompt, task.images),
-                tools=task.tools
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
             )
         else:
-            agent_output = executor_agent.chat(task_prompt, tools=task.tools)
+            agent_output = executor_agent.chat(
+                task_prompt,
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
 
         if agent_output:
             task_output = TaskOutput(

praisonaiagents-0.0.24/praisonaiagents/tools/__init__.py

@@ -0,0 +1,167 @@
+"""Tools package for PraisonAI Agents"""
+from importlib import import_module
+from typing import Any
+
+# Map of function names to their module and class (if any)
+TOOL_MAPPINGS = {
+    # Direct functions
+    'internet_search': ('.duckduckgo_tools', None),
+    'duckduckgo': ('.duckduckgo_tools', None),
+    
+    # Class methods from YFinance
+    'get_stock_price': ('.yfinance_tools', 'YFinanceTools'),
+    'get_stock_info': ('.yfinance_tools', 'YFinanceTools'),
+    'get_historical_data': ('.yfinance_tools', 'YFinanceTools'),
+    'yfinance': ('.yfinance_tools', 'YFinanceTools'),
+
+    # File Tools
+    'read_file': ('.file_tools', 'FileTools'),
+    'write_file': ('.file_tools', 'FileTools'),
+    'list_files': ('.file_tools', 'FileTools'),
+    'get_file_info': ('.file_tools', 'FileTools'),
+    'copy_file': ('.file_tools', 'FileTools'),
+    'move_file': ('.file_tools', 'FileTools'),
+    'delete_file': ('.file_tools', 'FileTools'),
+    'file_tools': ('.file_tools', 'FileTools'),
+
+    # CSV Tools
+    'read_csv': ('.csv_tools', 'CSVTools'),
+    'write_csv': ('.csv_tools', 'CSVTools'),
+    'merge_csv': ('.csv_tools', 'CSVTools'),
+    'analyze_csv': ('.csv_tools', 'CSVTools'),
+    'split_csv': ('.csv_tools', 'CSVTools'),
+    'csv_tools': ('.csv_tools', 'CSVTools'),
+
+    # JSON Tools
+    'read_json': ('.json_tools', 'JSONTools'),
+    'write_json': ('.json_tools', 'JSONTools'),
+    'merge_json': ('.json_tools', 'JSONTools'),
+    'validate_json': ('.json_tools', 'JSONTools'),
+    'analyze_json': ('.json_tools', 'JSONTools'),
+    'transform_json': ('.json_tools', 'JSONTools'),
+    'json_tools': ('.json_tools', 'JSONTools'),
+
+    # Excel Tools
+    'read_excel': ('.excel_tools', 'ExcelTools'),
+    'write_excel': ('.excel_tools', 'ExcelTools'),
+    'merge_excel': ('.excel_tools', 'ExcelTools'),
+    'create_chart': ('.excel_tools', 'ExcelTools'),
+    'add_chart_to_sheet': ('.excel_tools', 'ExcelTools'),
+    'excel_tools': ('.excel_tools', 'ExcelTools'),
+
+    # XML Tools
+    'read_xml': ('.xml_tools', 'XMLTools'),
+    'write_xml': ('.xml_tools', 'XMLTools'),
+    'transform_xml': ('.xml_tools', 'XMLTools'),
+    'validate_xml': ('.xml_tools', 'XMLTools'),
+    'xml_to_dict': ('.xml_tools', 'XMLTools'),
+    'dict_to_xml': ('.xml_tools', 'XMLTools'),
+    'xpath_query': ('.xml_tools', 'XMLTools'),
+    'xml_tools': ('.xml_tools', 'XMLTools'),
+
+    # YAML Tools
+    'read_yaml': ('.yaml_tools', 'YAMLTools'),
+    'write_yaml': ('.yaml_tools', 'YAMLTools'),
+    'merge_yaml': ('.yaml_tools', 'YAMLTools'),
+    'validate_yaml': ('.yaml_tools', 'YAMLTools'),
+    'analyze_yaml': ('.yaml_tools', 'YAMLTools'),
+    'transform_yaml': ('.yaml_tools', 'YAMLTools'),
+    'yaml_tools': ('.yaml_tools', 'YAMLTools'),
+
+    # Calculator Tools
+    'evaluate': ('.calculator_tools', 'CalculatorTools'),
+    'solve_equation': ('.calculator_tools', 'CalculatorTools'),
+    'convert_units': ('.calculator_tools', 'CalculatorTools'),
+    'calculate_statistics': ('.calculator_tools', 'CalculatorTools'),
+    'calculate_financial': ('.calculator_tools', 'CalculatorTools'),
+    'calculator_tools': ('.calculator_tools', 'CalculatorTools'),
+
+    # Python Tools
+    'execute_code': ('.python_tools', 'PythonTools'),
+    'analyze_code': ('.python_tools', 'PythonTools'),
+    'format_code': ('.python_tools', 'PythonTools'),
+    'lint_code': ('.python_tools', 'PythonTools'),
+    'disassemble_code': ('.python_tools', 'PythonTools'),
+    'python_tools': ('.python_tools', 'PythonTools'),
+
+    # Pandas Tools
+    'filter_data': ('.pandas_tools', 'PandasTools'),
+    'get_summary': ('.pandas_tools', 'PandasTools'),
+    'group_by': ('.pandas_tools', 'PandasTools'),
+    'pivot_table': ('.pandas_tools', 'PandasTools'),
+    'pandas_tools': ('.pandas_tools', 'PandasTools'),
+
+    # Wikipedia Tools
+    'search': ('.wikipedia_tools', 'WikipediaTools'),
+    'get_wikipedia_summary': ('.wikipedia_tools', 'WikipediaTools'),
+    'get_wikipedia_page': ('.wikipedia_tools', 'WikipediaTools'),
+    'get_random_wikipedia': ('.wikipedia_tools', 'WikipediaTools'),
+    'set_wikipedia_language': ('.wikipedia_tools', 'WikipediaTools'),
+    'wikipedia_tools': ('.wikipedia_tools', 'WikipediaTools'),
+
+    # Newspaper Tools
+    'get_article': ('.newspaper_tools', 'NewspaperTools'),
+    'get_news_sources': ('.newspaper_tools', 'NewspaperTools'),
+    'get_articles_from_source': ('.newspaper_tools', 'NewspaperTools'),
+    'get_trending_topics': ('.newspaper_tools', 'NewspaperTools'),
+    'newspaper_tools': ('.newspaper_tools', 'NewspaperTools'),
+
+    # arXiv Tools
+    'search_arxiv': ('.arxiv_tools', 'ArxivTools'),
+    'get_arxiv_paper': ('.arxiv_tools', 'ArxivTools'),
+    'get_papers_by_author': ('.arxiv_tools', 'ArxivTools'),
+    'get_papers_by_category': ('.arxiv_tools', 'ArxivTools'),
+    'arxiv_tools': ('.arxiv_tools', 'ArxivTools'),
+
+    # Spider Tools
+    'scrape_page': ('.spider_tools', 'SpiderTools'),
+    'extract_links': ('.spider_tools', 'SpiderTools'),
+    'crawl': ('.spider_tools', 'SpiderTools'),
+    'extract_text': ('.spider_tools', 'SpiderTools'),
+    'spider_tools': ('.spider_tools', 'SpiderTools'),
+
+    # DuckDB Tools
+    'query': ('.duckdb_tools', 'DuckDBTools'),
+    'create_table': ('.duckdb_tools', 'DuckDBTools'),
+    'load_data': ('.duckdb_tools', 'DuckDBTools'),
+    'export_data': ('.duckdb_tools', 'DuckDBTools'),
+    'get_table_info': ('.duckdb_tools', 'DuckDBTools'),
+    'analyze_data': ('.duckdb_tools', 'DuckDBTools'),
+    'duckdb_tools': ('.duckdb_tools', 'DuckDBTools'),
+
+    # Shell Tools
+    'execute_command': ('.shell_tools', 'ShellTools'),
+    'list_processes': ('.shell_tools', 'ShellTools'),
+    'kill_process': ('.shell_tools', 'ShellTools'),
+    'get_system_info': ('.shell_tools', 'ShellTools'),
+    'shell_tools': ('.shell_tools', 'ShellTools'),
+}
+
+_instances = {}  # Cache for class instances
+
+def __getattr__(name: str) -> Any:
+    """Smart lazy loading of tools with class method support."""
+    if name not in TOOL_MAPPINGS:
+        raise AttributeError(f"module '{__package__}' has no attribute '{name}'")
+    
+    module_path, class_name = TOOL_MAPPINGS[name]
+    
+    if class_name is None:
+        # Direct function import
+        module = import_module(module_path, __package__)
+        if name in ['duckduckgo', 'file_tools', 'pandas_tools', 'wikipedia_tools',
+                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
+            return module  # Returns the callable module
+        return getattr(module, name)
+    else:
+        # Class method import
+        if class_name not in _instances:
+            module = import_module(module_path, __package__)
+            class_ = getattr(module, class_name)
+            _instances[class_name] = class_()
+        
+        # Get the method and bind it to the instance
+        method = getattr(_instances[class_name], name)
+        return method
+
+__all__ = list(TOOL_MAPPINGS.keys())

praisonaiagents-0.0.24/praisonaiagents/tools/arxiv_tools.py

@@ -0,0 +1,292 @@
+"""Tools for searching and retrieving papers from arXiv.
+
+Usage:
+from praisonaiagents.tools import arxiv_tools
+papers = arxiv_tools.search("quantum computing")
+paper = arxiv_tools.get_paper("2401.00123")
+
+or
+from praisonaiagents.tools import search_arxiv, get_arxiv_paper
+papers = search_arxiv("quantum computing")
+"""
+
+import logging
+from typing import List, Dict, Union, Optional, Any
+from importlib import util
+import json
+
+# Map sort criteria to arxiv.SortCriterion
+SORT_CRITERIA = {
+    "relevance": "Relevance",
+    "lastupdateddate": "LastUpdatedDate",
+    "submitteddate": "SubmittedDate"
+}
+
+# Map sort order to arxiv.SortOrder
+SORT_ORDER = {
+    "ascending": "Ascending",
+    "descending": "Descending"
+}
+
+class ArxivTools:
+    """Tools for searching and retrieving papers from arXiv."""
+    
+    def __init__(self):
+        """Initialize ArxivTools and check for arxiv package."""
+        self._check_arxiv()
+        
+    def _check_arxiv(self):
+        """Check if arxiv package is installed."""
+        if util.find_spec("arxiv") is None:
+            raise ImportError("arxiv package is not available. Please install it using: pip install arxiv")
+        global arxiv
+        import arxiv
+
+    def search(
+        self,
+        query: str,
+        max_results: int = 10,
+        sort_by: str = "relevance",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Search arXiv for papers matching the query.
+        
+        Args:
+            query: Search query (e.g., "quantum computing", "author:Einstein")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results. If None, includes all.
+                Available fields: ["title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"]
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        try:
+            import arxiv
+            
+            # Configure search client
+            client = arxiv.Client()
+            
+            # Map sort criteria
+            sort_by_enum = getattr(arxiv.SortCriterion, SORT_CRITERIA[sort_by.lower()])
+            sort_order_enum = getattr(arxiv.SortOrder, SORT_ORDER[sort_order.lower()])
+            
+            # Build search query
+            search = arxiv.Search(
+                query=query,
+                max_results=max_results,
+                sort_by=sort_by_enum,
+                sort_order=sort_order_enum
+            )
+            
+            # Execute search
+            results = []
+            for result in client.results(search):
+                # Convert to dict with selected fields
+                paper = self._result_to_dict(result, include_fields)
+                results.append(paper)
+            
+            return results
+        except Exception as e:
+            error_msg = f"Error searching arXiv: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def get_paper(
+        self,
+        paper_id: str,
+        include_fields: Optional[List[str]] = None
+    ) -> Union[Dict[str, Any], Dict[str, str]]:
+        """
+        Get details of a specific paper by its arXiv ID.
+        
+        Args:
+            paper_id: arXiv paper ID (e.g., "2401.00123")
+            include_fields: List of fields to include in results. If None, includes all.
+                Available fields: ["title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"]
+            
+        Returns:
+            Dict: Paper details or error dict
+        """
+        try:
+            import arxiv
+            
+            # Configure client
+            client = arxiv.Client()
+            
+            # Get paper by ID
+            search = arxiv.Search(id_list=[paper_id])
+            results = list(client.results(search))
+            
+            if not results:
+                return {"error": f"Paper with ID {paper_id} not found"}
+            
+            # Convert to dict with selected fields
+            paper = self._result_to_dict(results[0], include_fields)
+            return paper
+        except Exception as e:
+            error_msg = f"Error getting paper {paper_id}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def get_papers_by_author(
+        self,
+        author: str,
+        max_results: int = 10,
+        sort_by: str = "submittedDate",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Get papers by a specific author.
+        
+        Args:
+            author: Author name (e.g., "Einstein")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        query = f'au:"{author}"'
+        return self.search(query, max_results, sort_by, sort_order, include_fields)
+
+    def get_papers_by_category(
+        self,
+        category: str,
+        max_results: int = 10,
+        sort_by: str = "submittedDate",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Get papers from a specific category.
+        
+        Args:
+            category: arXiv category (e.g., "cs.AI", "physics.gen-ph")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        query = f'cat:{category}'
+        return self.search(query, max_results, sort_by, sort_order, include_fields)
+
+    def _result_to_dict(
+        self,
+        result: Any,
+        include_fields: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Convert arxiv.Result to dictionary with selected fields."""
+        # Default fields to include
+        if include_fields is None:
+            include_fields = [
+                "title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"
+            ]
+        
+        # Build paper dict with selected fields
+        paper = {}
+        
+        # Always include these basic fields
+        paper["arxiv_id"] = result.entry_id.split("/")[-1]
+        paper["updated"] = result.updated.isoformat() if result.updated else None
+        paper["published"] = result.published.isoformat() if result.published else None
+        
+        # Add requested fields
+        if "title" in include_fields:
+            paper["title"] = result.title
+        if "authors" in include_fields:
+            paper["authors"] = [str(author) for author in result.authors]
+        if "summary" in include_fields:
+            paper["summary"] = result.summary
+        if "comment" in include_fields:
+            paper["comment"] = result.comment
+        if "journal_ref" in include_fields:
+            paper["journal_ref"] = result.journal_ref
+        if "doi" in include_fields:
+            paper["doi"] = result.doi
+        if "primary_category" in include_fields:
+            paper["primary_category"] = result.primary_category
+        if "categories" in include_fields:
+            paper["categories"] = result.categories
+        if "links" in include_fields:
+            paper["pdf_url"] = result.pdf_url
+            paper["abstract_url"] = f"https://arxiv.org/abs/{paper['arxiv_id']}"
+        
+        return paper
+
+# Create instance for direct function access
+_arxiv_tools = ArxivTools()
+search_arxiv = _arxiv_tools.search
+get_arxiv_paper = _arxiv_tools.get_paper
+get_papers_by_author = _arxiv_tools.get_papers_by_author
+get_papers_by_category = _arxiv_tools.get_papers_by_category
+
+if __name__ == "__main__":
+    # Example usage
+    print("\n==================================================")
+    print("ArxivTools Demonstration")
+    print("==================================================\n")
+    
+    # 1. Search for papers
+    print("1. Searching for Papers")
+    print("------------------------------")
+    query = "quantum computing"
+    papers = search_arxiv(query, max_results=3)
+    print(f"Papers about {query}:")
+    if isinstance(papers, list):
+        print(json.dumps(papers, indent=2))
+    else:
+        print(papers)  # Show error
+    print()
+    
+    # 2. Get specific paper
+    print("2. Getting Specific Paper")
+    print("------------------------------")
+    if isinstance(papers, list) and papers:
+        paper_id = papers[0]["arxiv_id"]
+        paper = get_arxiv_paper(paper_id)
+        print(f"Paper {paper_id}:")
+        if "error" not in paper:
+            print(json.dumps(paper, indent=2))
+        else:
+            print(paper)  # Show error
+    print()
+    
+    # 3. Get papers by author
+    print("3. Getting Papers by Author")
+    print("------------------------------")
+    author = "Yoshua Bengio"
+    author_papers = get_papers_by_author(author, max_results=3)
+    print(f"Papers by {author}:")
+    if isinstance(author_papers, list):
+        print(json.dumps(author_papers, indent=2))
+    else:
+        print(author_papers)  # Show error
+    print()
+    
+    # 4. Get papers by category
+    print("4. Getting Papers by Category")
+    print("------------------------------")
+    category = "cs.AI"
+    category_papers = get_papers_by_category(category, max_results=3)
+    print(f"Papers in category {category}:")
+    if isinstance(category_papers, list):
+        print(json.dumps(category_papers, indent=2))
+    else:
+        print(category_papers)  # Show error
+    
+    print("\n==================================================")
+    print("Demonstration Complete")
+    print("==================================================")