ToolUniverse

https://zitniklab.hms.harvard.edu/ToolUniverse
Admin
ToolUniverse is a unified ecosystem that transforms large language models into AI scientists by...
Tokens:2,858,576
Snippets:15,238
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get Quick Start Guide

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/package_tool.html

Returns a list of quick start steps, defaulting to standard installation and import instructions if not provided.

```python
    def _get_quick_start_guide(self) -> list:
        """Get quick start guide steps"""
        if self.local_info.get("quick_start"):
            return self.local_info["quick_start"]

        import_name = self.local_info.get("import_name", self.package_name)
        return [
            f"1. Install the package: pip install {self.package_name}",
            f"2. Import in your Python code: import {import_name}",
            "3. Check the documentation for detailed usage examples",
            "4. Start with basic examples and gradually explore advanced features",
        ]
```

--------------------------------

### Install and Start vLLM Server

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/vllm_support.html

Install vLLM and start a local inference server. Ensure the model name matches the one you intend to use.

```bash
pip install vllm
vllm serve meta-llama/Llama-3.1-8B-Instruct
```

--------------------------------

### SMCP Server Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/reference/cli_tools.html

Examples for starting the SMCP server with various configurations.

```bash
# Start server with all tools (default: 0.0.0.0:7000)
tooluniverse-smcp

# Start with compact mode (recommended for AI assistants)
tooluniverse-smcp --compact-mode

# Start with specific categories only
tooluniverse-smcp --categories uniprot ChEMBL opentarget

# Start with custom port
tooluniverse-smcp --port 3001

# Load workspace configuration
tooluniverse-smcp --load "community/proteomics-toolkit"
```

--------------------------------

### Example Model Weights Setup and Environment Variable Configuration

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/remote/immune_compass.html

A practical example demonstrating the creation of the model weights directory, downloading necessary model files using `wget`, and setting the `COMPASS_MODEL_PATH` environment variable.

```bash
# Create directory structure
mkdir -p /path/to/your/compass/checkpoint
cd /path/to/your/compass/checkpoint

# Download model weights to checkpoint directory
wget https://www.immuno-compass.com/download/model/LOCO/pft_leave_IMVigor210.pt
wget https://www.immuno-compass.com/download/model/LOCO/pft_leave_Gide.pt

# Set environment variable
export COMPASS_MODEL_PATH="/path/to/your/compass"

```

--------------------------------

### Install and Start ESM Server

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/remote/esm.html

Commands to clone the repository, set up the virtual environment, and launch the ESM server.

```bash
# Clone the ToolUniverse repository
git clone https://github.com/mims-harvard/ToolUniverse.git
cd ToolUniverse

# Create a virtual environment
uv venv esm --python 3.10
source esm/bin/activate

# Install ToolUniverse package and ESM dependencies
uv pip install -e .
uv pip install -r src/tooluniverse/remote/esm/requirements.txt
```

```bash
python src/tooluniverse/remote/esm/esm_tool.py
```

```bash
cd ToolUniverse  # Go back to the same ToolUniverse directory
source esm/bin/activate
```

--------------------------------

### Get OpenBabel Package Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/cheminformatics_tools.html

Retrieve comprehensive information about OpenBabel, a chemical format conversion and analysis tool. Set `include_examples` to true to also get usage examples and a quick start guide.

```python
query = {
    "name": "get_openbabel_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get Package Usage Example

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/package_tool.html

Returns a pre-defined usage example or generates a basic template if none exists in the local configuration.

```python
    def _get_usage_example(self) -> str:
        """Get usage example for the package"""
        if self.local_info.get("usage_example"):
            return self.local_info["usage_example"]

        import_name = self.local_info.get("import_name", self.package_name)
        return f"""# Basic usage example for {self.package_name}
import {import_name}

# Add your code here - check the documentation for specific usage
print({import_name}.__version__)"""
```

--------------------------------

### Install and Start ToolUniverse HTTP API Server

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/http_api.html

Install the full ToolUniverse package and start the HTTP API server. This command starts a single worker with an async thread pool on host 0.0.0.0 and port 8080.

```bash
# Install full ToolUniverse package
pip install tooluniverse

# Start HTTP API server (single worker with async thread pool)
tooluniverse-http-api --host 0.0.0.0 --port 8080

```

--------------------------------

### Manage MCP Server Lifecycle

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/api/tooluniverse.mcp_tool_registry.html

Provides examples for starting MCP servers for specific ports, all tools, or with custom configurations.

```python
# Start server for specific port start_mcp_server(port=8001)
# Start all servers start_mcp_server()
# Start with custom configuration start_mcp_server(max_workers=20, debug=True)
```

--------------------------------

### Get RDKit Package Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/cheminformatics_tools.html

Get comprehensive details about RDKit, a cheminformatics and machine learning toolkit. Include usage examples and a quick start guide by setting `include_examples` to true.

```python
query = {
    "name": "get_rdkit_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get pybedtools Package Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieves comprehensive information about the pybedtools package, a Python wrapper for BEDTools. Set 'include_examples' to true to also get usage examples and a quick start guide.

```python
query = {
    "name": "get_pybedtools_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Alternative Startup Methods

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/literature_search_web_ui_tutorial.html

Commands to start the web UI directly using Python scripts or modules.

```bash
# Method 1: Direct Python execution
cd /path/to/ToolUniverse/src/tooluniverse/web_tools/literature_search_ui
python simple_app.py

# Method 2: Using Python module
python -m tooluniverse.web_tools.literature_search_ui.simple_app
```

--------------------------------

### Get PyLiftover Package Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieves comprehensive information about the PyLiftover package, used for genomic coordinate conversion between assemblies. Set 'include_examples' to true to include usage examples and a quick start guide.

```python
query = {
    "name": "get_pyliftover_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get PyTorch Package Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/machine_learning_tools.html

Obtains information about the PyTorch package, an open-source machine learning framework. Can optionally include usage examples and a quick start guide.

```python
query = {
    "name": "get_pytorch_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get pyfaidx Package Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieves comprehensive information about the pyfaidx package, used for efficient FASTA file indexing and random access. Set 'include_examples' to true to include usage examples and a quick start guide.

```python
query = {
    "name": "get_pyfaidx_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Run Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/visualization_tutorial.html

Commands to execute the provided example scripts.

```bash
# Quick examples
python examples/visualization_quickstart.py

# More examples
python examples/visualization_examples.py
```

--------------------------------

### Create Example Usage Script

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/expand_tooluniverse/contributing/local_tools.html

Develop an example script (`examples/my_new_tool/my_new_tool_example.py`) that demonstrates how to use your new tool. This script should follow the repository's contribution pattern, including loading the tool via `ToolUniverse` and testing it with various inputs.

```python
"""Example usage of MyNewTool.

This example follows the documentation pattern for contributing tools to the
repository. It demonstrates the multi-file structure:
- my_new_tool.py: Tool class definition
- my_new_tool_tools.json: Tool configuration
- my_new_tool_example.py: Example usage

Note: In a real contribution, these files would be placed in:
- src/tooluniverse/my_new_tool.py
- src/tooluniverse/data/my_new_tool_tools.json
- examples/my_new_tool_example.py

And you would need to modify __init__.py in 4 locations.
"""

import os
import sys

# Import the tool class to register it
from my_new_tool import MyNewTool  # noqa: E402, F401

from tooluniverse import ToolUniverse  # noqa: E402


def main():
    # Initialize ToolUniverse
    tu = ToolUniverse()

    # Load tools with the config file
    # In a real contribution, this would be in default_tool_files
    current_dir = os.path.dirname(os.path.abspath(__file__))
    config_path = os.path.join(current_dir, 'my_new_tool_tools.json')
    tu.load_tools(tool_config_files={"my_new_tool": config_path})

    # Use the tool
    result = tu.run({
        "name": "my_new_tool",
        "arguments": {"input": "hello world"}
    })

    print(f"Result: {result}")

    # Test with different inputs
    test_inputs = ["hello", "world", "python"]
    for text in test_inputs:
        result = tu.run({
            "name": "my_new_tool",
            "arguments": {"input": text}
        })
        print(f"'{text}' -> '{result.get('result', 'ERROR')}'")

if __name__ == "__main__":
    main()


```

--------------------------------

### Get scikit-learn Package Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/machine_learning_tools.html

Fetches information about the scikit-learn package, offering tools for predictive data analysis. Can optionally include usage examples and a quick start guide.

```python
query = {
    "name": "get_scikit_learn_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Prepare Tool Configurations for Example Usage (Deprecated)

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/api/tooluniverse.execute_function.html

Prepare tool configurations for example usage by keeping an extended set of keys. This method is deprecated; use `prepare_tool_prompts(mode='example')` instead.

```python
tu.prepare_tool_examples(_tool_list_)
```

--------------------------------

### Retrieve Local Package Information

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/package_tool.html

Method to compile package metadata from local configuration, optionally including usage examples and quick start guides.

```python
    def _get_local_info(self, include_examples: bool = True) -> Dict[str, Any]:
        """Get package information from local configuration"""
        if not self.local_info:
            return {
                "status": "error",
                "error": f"No local information available for package '{self.package_name}'",
                "package_name": self.package_name,
            }

        result = {
            "package_name": self.local_info.get("name", self.package_name),
            "description": self.local_info.get(
                "description", "No description available"
            ),
            "version": self.local_info.get("version", "Check PyPI for latest"),
            "category": self.local_info.get("category", "General"),
            "license": self.local_info.get("license", "Not specified"),
            "documentation": self.local_info.get("documentation", ""),
            "repository": self.local_info.get("repository", ""),
            "import_name": self.local_info.get("import_name", self.package_name),
            "python_versions": self.local_info.get("python_versions", ["3.6+"]),
            "dependencies": self.local_info.get("dependencies", []),
            "popularity": self.local_info.get("popularity", 0),
            "keywords": self.local_info.get("keywords", []),
            "installation": self._get_installation_instructions(),
            "source": "local",
        }

        if include_examples:
            result["usage_example"] = self._get_usage_example()
            result["quick_start"] = self._get_quick_start_guide()

        return result
```

--------------------------------

### Initialize ToolUniverse

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/clinical_guidelines_tools.html

Basic setup to import the library, initialize the client, and load available tools.

```python
from tooluniverse import ToolUniverse

tu = ToolUniverse()
tu.load_tools()

# Search guidelines
results = tu.run({
    "name": "NICE_Clinical_Guidelines_Search",
    "arguments": {
        "query": "diabetes",
        "limit": 5
    }
})

# Extract full text
full_text = tu.run({
    "name": "NICE_Guideline_Full_Text",
    "arguments": {
        "url": results[0]['url']
    }
})
```

--------------------------------

### Get SchNetPack Package Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/machine_learning_tools.html

Retrieves comprehensive information about the SchNetPack package, a deep-learning toolbox for molecules and materials. Can optionally include usage examples and a quick-start guide.

```python
query = {
    "name": "get_schnetpack_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Initialize GINGuidelinesTool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/unified_guideline_tools.html

Sets up the tool with the base URL and session headers required for web scraping.

```python
def __init__(self, tool_config):
	super().__init__(tool_config)
	self.base_url = "https://guidelines.ebmportal.com"
	self.search_url = f"{self.base_url}/guidelines-international-network"
	self.session = requests.Session()
	self.session.headers.update(
		{
			"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
			"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
			"Accept-Language": "en-US,en;q=0.5",
		}
	)
```

--------------------------------

### Fetch Package Info from PyPI

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/package_tool.html

Fetches package information from the PyPI API. Includes error handling for network requests and merges local information if available. Optionally includes usage examples and quick start guides.

```python
def _get_pypi_info(self, include_examples: bool = True) -> Dict[str, Any]:
 """Fetch package information from PyPI API"""
 url = f"https://pypi.org/pypi/{self.package_name}/json"

 try:
 response = requests.get(url, timeout=self.pypi_timeout)
 response.raise_for_status()
 pypi_data = response.json()

 info = pypi_data.get("info", {})

 # Build response with PyPI data
 result = {
 "package_name": info.get("name", self.package_name),
 "description": info.get("summary", "No description available"),
 "version": info.get("version", "Unknown"),
 "author": info.get("author", "Unknown"),
 "license": info.get("license", "Not specified"),
 "home_page": info.get("home_page", ""),
 "documentation": info.get("project_urls", {}).get("Documentation", ""),
 "repository": info.get("project_urls", {}).get(
 "Repository", info.get("project_urls", {}).get("Source", "")
 ),
 "python_versions": info.get("classifiers", []),
 "keywords": (
 info.get("keywords", "").split(",") if info.get("keywords") else []
 ),
 "installation": {
 "pip": f"pip install {self.package_name}",
 "conda": f"conda install {self.package_name}",
 "pip_upgrade": f"pip install --upgrade {self.package_name}",
 },
 "source": "pypi",
 "last_updated": pypi_data.get("last_serial", "Unknown"),
 }

 # Merge with local enhanced information
 local_info = self.local_info
 if local_info:
 result["category"] = local_info.get("category", "General")
 result["import_name"] = local_info.get("import_name", self.package_name)
 result["popularity"] = local_info.get("popularity", 0)

 # Override with better local descriptions if available
 if local_info.get("description") and len(
 local_info["description"]
 ) > len(result["description"]):
 result["description"] = local_info["description"]

 # Add local documentation if PyPI doesn't have it
 if not result["documentation"] and local_info.get("documentation"):
 result["documentation"] = local_info["documentation"]

 # Add custom installation instructions
 if local_info.get("installation"):
 result["installation"].update(local_info["installation"])

 # Add examples if requested
 if include_examples:
 result["usage_example"] = self._get_usage_example()
 result["quick_start"] = self._get_quick_start_guide()

 return result

 except requests.exceptions.RequestException as e:
 raise Exception(f"Failed to fetch from PyPI: {str(e)}")
```

--------------------------------

### Create a Simple 'Hello World' Tool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/expand_tooluniverse/local_tools/local_tools_tutorial.html

This is the simplest example of a local tool. It requires importing `register_tool` and `BaseTool`, decorating the class, and implementing the `run` method. The tool is then registered and can be used with ToolUniverse.

```python
# hello_tool.py - Save this file anywhere
from tooluniverse.tool_registry import register_tool
from tooluniverse.base_tool import BaseTool

@register_tool('HelloTool', config={
    "name": "hello_tool",
    "description": "Say hello"
})
class HelloTool(BaseTool):
    def run(self, arguments=None, **kwargs):
        return {"message": "Hello!", "success": True}

# Usage
from tooluniverse import ToolUniverse
from hello_tool import HelloTool  # This registers the tool

tu = ToolUniverse()
tu.load_tools()

result = tu.run({
    "name": "hello_tool",
    "arguments": {}
})
print(result)  # {"message": "Hello!", "success": True}

```

--------------------------------

### Run get_qutip_info Tool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/physics_astronomy_tools.html

Example of how to run the get_qutip_info tool. No parameters are required.

```python
query = {
    "name": "get_qutip_info",
    "arguments": {
    }
}
result = tu.run(query)

```

--------------------------------

### Install COMPASS Library with uv

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/remote/immune_compass.html

Set up a virtual environment using uv and install the COMPASS library and its dependencies from a requirements file.

```bash
# create a uv virtual enviroment for COMPASS setup
uv venv compass --python 3.10
source compass/bin/activate
uv pip install -r requirements.txt

# Install COMPASS
uv pip install immuno-compass

```

--------------------------------

### Initialize NICE Guideline Tool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/unified_guideline_tools.html

Sets up the tool class for fetching content from NICE guideline pages, including session configuration and user-agent headers.

```python
@register_tool()
class NICEGuidelineFullTextTool(BaseTool):
    """
    Fetch full text content from NICE guideline pages.
    Takes a NICE guideline URL and extracts the complete guideline content.
    """

    def __init__(self, tool_config):
        super().__init__(tool_config)
        self.base_url = "https://www.nice.org.uk"
        self.session = requests.Session()
        self.session.headers.update(
            {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
            }
        )

    def run(self, arguments):
        url = arguments.get("url", "")

        if not url:
```

--------------------------------

### Get Package to Install

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/python_executor_tool.html

Determines the actual package name to install, particularly for submodules where the parent package should be installed instead.

```python
def _get_package_to_install(self, package: str) -> str:
        """Get the actual package name to install (parent package for submodules)"""
        if "." in package:
            # For submodules like 'keggtools.keggrest', install the parent package 'keggtools'
            return package.split(".")[0]
        return package
```

--------------------------------

### Setup Virtual Environment

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/about/contributing.html

Create and activate a Python virtual environment.

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

--------------------------------

### Invoke Installed Tool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/make_your_data_agent_searchable.html

Example of calling an installed tool within a ToolUniverse or Codex session.

```python
tu.tools.cardiology_expert_search(…)
```

--------------------------------

### Discover MCP Tools Example

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/mcp_integration.html

Demonstrates how to discover available tools from MCP servers without loading them. Shows how to iterate through discovered tools and print their names and descriptions.

```python
        tu = ToolUniverse()

        discovery = tu.discover_mcp_tools([
            "http://localhost:8001",
            "http://ml-server:8002"
        ])

        for server, info in discovery["servers"].items():
            print(f"\n{server}:")
            for tool in info.get("tools", []):
                print(f"  - {tool['name']}: {tool['description']}")
```

--------------------------------

### Get ViennaRNA Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieve information about the ViennaRNA package. Set include_examples to true to also get usage examples.

```python
query = {
    "name": "get_viennarna_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get ReportLab Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieve information about the ReportLab package. Set include_examples to true to also get usage examples.

```python
query = {
    "name": "get_reportlab_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Run Demo Script

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/clinical_guidelines_tools.html

Execute the provided demonstration script from the command line.

```bash
python examples/clinical_guidelines_demo.py
```

--------------------------------

### Prepare Tool Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/execute_function.html

Prepares tool configurations for example usage by keeping an extended set of keys. This method is deprecated and `prepare_tool_prompts(mode='example')` should be used instead.

```APIDOC
## POST /api/tools/prepare_examples

### Description
Prepare tool configurations for example usage by keeping extended set of keys.

### Method
POST

### Endpoint
/api/tools/prepare_examples

### Parameters
#### Request Body
- **tool_list** (list) - Required - List of tool configuration dictionaries.

### Request Example
```json
{
  "tool_list": [
    {"name": "tool1", "version": "1.0", "description": "desc1", "examples": ["ex1"]},
    {"name": "tool2", "version": "2.0", "description": "desc2", "examples": ["ex2"]}
  ]
}
```

### Response
#### Success Response (200)
- **tool_list** (list) - Deep copy of tool list with only example-relevant keys.

#### Response Example
```json
{
  "tool_list": [
    {"name": "tool1", "examples": ["ex1"]},
    {"name": "tool2", "examples": ["ex2"]}
  ]
}
```
```

--------------------------------

### Get Pysam Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieve information about the pysam package. Set include_examples to true to also get usage examples.

```python
query = {
    "name": "get_pysam_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Basic tooluniverse-smcp-stdio Startup

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/loading_tools.html

Start the stdio-specific server for desktop applications.

```bash
# Start stdio server with default SummarizationHook enabled
tooluniverse-smcp-stdio

# Start with specific categories
tooluniverse-smcp-stdio --categories uniprot ChEMBL opentarget
```

--------------------------------

### Get PyRanges Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/genomics_tools.html

Retrieve information about the PyRanges package. Set include_examples to true to also get usage examples.

```python
query = {
    "name": "get_pyranges_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Prepare tool examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/execute_function.html

Prepares tool configurations for example usage. This is deprecated in favor of prepare_tool_prompts(mode='example').

```python
    def prepare_tool_examples(self, tool_list):
        """
        Prepare tool configurations for example usage by keeping extended set of keys.

        DEPRECATED: Use prepare_tool_prompts(mode='example') instead.

        Args:
            tool_list (list): List of tool configuration dictionaries.

        Returns:
            list: Deep copy of tool list with only example-relevant keys.
        """
        warnings.warn(
            "prepare_tool_examples() is deprecated and will be removed in v2.0. "
            "Use prepare_tool_prompts(mode='example') instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        return self.prepare_tool_prompts(tool_list, mode="example")
```

--------------------------------

### Set Up ToolUniverse with Antigravity

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/building_ai_scientists/antigravity.html

Use this command within Antigravity to initiate the ToolUniverse setup process by reading the provided setup guide.

```shell
Read https://aiscientist.tools/setup.md and set up ToolUniverse for me.

```

--------------------------------

### Initialize and Run QuickGOTool

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/quickgo_tool.html

The QuickGOTool class requires a configuration dictionary and provides a run method to execute API queries based on the configured endpoint.

```python
@register_tool("QuickGOTool")
class QuickGOTool(BaseTool):
    """
    Tool for querying the EBI QuickGO Gene Ontology browser.

    QuickGO provides comprehensive GO annotation data with filtering
    by gene product, GO term, taxon, evidence code, and more. Also
    provides ontology term details and hierarchical relationships.

    No authentication required.
    """

    def __init__(self, tool_config: Dict[str, Any]):
        super().__init__(tool_config)
        self.timeout = tool_config.get("timeout", 30)
        fields = tool_config.get("fields", {})
        self.endpoint = fields.get("endpoint", "annotation_gene")

    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
        """Execute the QuickGO API call."""
        try:
            return self._query(arguments)
        except requests.exceptions.Timeout:
            return {
                "status": "error",
                "error": f"QuickGO API request timed out after {self.timeout} seconds",
            }
        except requests.exceptions.ConnectionError:
            return {
                "status": "error",
                "error": "Failed to connect to QuickGO API. Check network connectivity.",
            }
        except requests.exceptions.HTTPError as e:
            return {
                "status": "error",
                "error": f"QuickGO API HTTP error: {e.response.status_code}",
            }
        except Exception as e:
            return {
                "status": "error",
                "error": f"Unexpected error querying QuickGO: {str(e)}",
            }
```

--------------------------------

### Initialize and Load All Tools

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/loading_tools.html

Basic setup for initializing the ToolUniverse instance and loading all available tools.

```python
from tooluniverse import ToolUniverse

# Initialize ToolUniverse
tu = ToolUniverse()

# Load all tools from all categories
tu.load_tools()

# Check how many tools were loaded
print(f"Loaded {len(tu.all_tools)} tools")

# List first 5 tools
tool_names = tu.list_built_in_tools(mode='list_name')
for tool in tool_names[:5]:
    print(f"  • {tool}")
```

--------------------------------

### Get Flask Information

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/bioinformatics_core_tools.html

Retrieve comprehensive information about the Flask web framework. Set include_examples to true to also get usage examples.

```python
query = {
    "name": "get_flask_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get DScribe Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/cheminformatics_tools.html

Retrieve comprehensive information about the DScribe package, including usage examples. Requires the 'include_examples' argument set to true.

```python
query = {
    "name": "get_dscribe_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Start Expert Feedback Server

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/guide/expert_feedback.html

Initialize the router servers for ToolUniverse and the Expert Web Interface.

```bash
tooluniverse-expert-feedback --start-server
# This starts:
# 🔌 Router-ToolUniverse Server on port 9876 (for ToolUniverse)
#  Router-Expert Server on port 9877 (for Expert Web Interface)
```

--------------------------------

### Get DeepChem Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/cheminformatics_tools.html

Retrieve comprehensive information about the DeepChem package, including usage examples. Requires the 'include_examples' argument set to true.

```python
query = {
    "name": "get_deepchem_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Get COBRApy Info with Examples

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/cheminformatics_tools.html

Retrieve comprehensive information about the COBRApy package, including usage examples. Requires the 'include_examples' argument set to true.

```python
query = {
    "name": "get_cobra_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)
```

--------------------------------

### Build Documentation

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/about/contributing.html

Commands to build and serve project documentation.

```bash
cd docs
make html
make serve  # Serve on http://localhost:8080
```

```bash
cd docs
make livehtml
```

--------------------------------

### Get Drug Names by Medication Guide Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/fda_drug_labeling_tools.html

Search for drug names based on information present in their medication guides. The `medguide_info` argument is mandatory.

```python
query = {
    "name": "FDA_get_drug_names_by_medication_guide",
    "arguments": {
        "medguide_info": "example_value"
    }
}
result = tu.run(query)
```

--------------------------------

### Initialize MCP Server Environment

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/remote/pinnacle.html

Set up a virtual environment and install dependencies for the MCP server.

```shell
# create a uv virtual enviroment for COMPASS setup
uv venv pinnacle --python 3.10
source pinnacle/bin/activate
uv pip install -r requirements.txt
```

--------------------------------

### Get PyMed Information using get_pymed_info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/bioinformatics_core_tools.html

This snippet shows how to get information about the PyMed package. Set 'include_examples' to true to also retrieve usage examples.

```python
query = {
    "name": "get_pymed_info",
    "arguments": {
        "include_examples": true
    }
}
result = tu.run(query)

```

--------------------------------

### Example .env File Configuration

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/reference/environment_variables.html

Demonstrates how to configure ToolUniverse settings using a .env file, including cache, logging, API keys, and LLM configurations.

```dotenv
# Cache configuration
TOOLUNIVERSE_CACHE_ENABLED=true
TOOLUNIVERSE_CACHE_MEMORY_SIZE=1024
TOOLUNIVERSE_CACHE_DEFAULT_TTL=3600

# Logging
TOOLUNIVERSE_LOG_LEVEL=INFO

# API Keys
NCBI_API_KEY=your_key_here
SEMANTIC_SCHOLAR_API_KEY=your_key_here

# LLM Configuration
TOOLUNIVERSE_LLM_DEFAULT_PROVIDER=openai
OPENAI_API_KEY=sk-...
```

--------------------------------

### Handle Missing cellxgene_census Package

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/_modules/tooluniverse/cellxgene_census_tool.html

This snippet demonstrates the error handling when the 'cellxgene_census' package is not installed. It returns an informative error message guiding the user on how to install the package.

```python
except ImportError:
            return {
                "status": "error",
                "error": "cellxgene_census package is required. Install with: pip install cellxgene-census",
            }
```

--------------------------------

### Get Statsmodels Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/machine_learning_tools.html

Retrieves comprehensive information about the statsmodels package, with an option to include examples.

```APIDOC
## GET /api/tools/get_statsmodels_info

### Description
Get comprehensive information about statsmodels – statistical modeling and econometrics.

### Method
GET

### Endpoint
/api/tools/get_statsmodels_info

### Parameters
#### Query Parameters
- **include_examples** (boolean) - Required - Whether to include usage examples and quick start guide.

### Request Example
```json
{
  "name": "get_statsmodels_info",
  "arguments": {
    "include_examples": true
  }
}
```

### Response
#### Success Response (200)
- **package_name** (string) - The name of the package.
- **version** (string) - The version of the package.
- **summary** (string) - A brief summary of the package.
- **description** (string) - A detailed description of the package.
- **documentation_url** (string) - URL to the package's documentation.
- **examples** (string) - Usage examples and quick start guide (if requested).

#### Response Example
```json
{
  "package_name": "statsmodels",
  "version": "0.13.5",
  "summary": "Statistical modeling and econometrics in Python.",
  "description": "Statistical modeling and econometrics in Python.",
  "documentation_url": "https://www.statsmodels.org/stable/index.html",
  "examples": "# Example usage:\nimport statsmodels.api as sm\nfrom statsmodels.datasets import boston\n
data = boston.load_pandas().data

# Define dependent and independent variables
y = data['MEDV']
X = data['RM']
X = sm.add_constant(X)

# Fit the OLS model
model = sm.OLS(y, X)
results = model.fit()

# Print the summary
print(results.summary())"
}
```
```

--------------------------------

### Configure Loading and Import Behavior

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/reference/environment_variables.html

Optimize startup performance and memory usage by adjusting loading strategies.

```bash
# Disable lazy loading (load all tools at startup)
export TOOLUNIVERSE_LAZY_LOADING=false

# Minimal imports for embedded systems
export TOOLUNIVERSE_LIGHT_IMPORT=true
```

--------------------------------

### Get Torch Geometric Info

Source: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/machine_learning_tools.html

Retrieves comprehensive information about PyTorch Geometric, with an option to include examples.

```APIDOC
## GET /api/tools/get_torch_geometric_info

### Description
Get comprehensive information about PyTorch Geometric – a high-performance library for graph neural networks widely used in molecular and materials science.

### Method
GET

### Endpoint
/api/tools/get_torch_geometric_info

### Parameters
#### Query Parameters
- **include_examples** (boolean) - Required - Whether to include usage examples and quick start guide.

### Request Example
```json
{
  "name": "get_torch_geometric_info",
  "arguments": {
    "include_examples": true
  }
}
```

### Response
#### Success Response (200)
- **package_name** (string) - The name of the package.
- **version** (string) - The version of the package.
- **summary** (string) - A brief summary of the package.
- **description** (string) - A detailed description of the package.
- **documentation_url** (string) - URL to the package's documentation.
- **examples** (string) - Usage examples and quick start guide (if requested).

#### Response Example
```json
{
  "package_name": "torch-geometric",
  "version": "2.3.0",
  "summary": "PyTorch Geometric: Geometric Deep Learning Extensions for PyTorch.",
  "description": "PyTorch Geometric: a high-performance library for graph neural networks widely used in molecular and materials science.",
  "documentation_url": "https://pytorch-geometric.readthedocs.io/en/latest/",
  "examples": "# Example usage:\nimport torch\nfrom torch_geometric.datasets import Planetoid\n
# Load the Cora dataset\ndataset = Planetoid(root='/tmp/Cora', name='Cora')\ndata = dataset[0]\n
# Print dataset information\nprint(f'Dataset: {dataset.num_classes} classes')\nprint(f'# Graphs: {len(dataset)}')\nprint(f'Number of nodes: {data.num_nodes}')\nprint(f'Number of edges: {data.num_edges}')\nprint(f'Node feature dimensions: {data.num_node_features}')\nprint(f'Node target dimensions: {data.num_node_targets}')"
}
```
```
Tokens:
Raw