Chat with new video file (index_id required for upload)

result = agent.tool.chat_video( prompt="Describe what happens in this video", video_path="/path/to/video.mp4", index_id="your-index-id" # or set TWELVELABS_PEGASUS_INDEX_ID env var ) ```

📦 Installation

Quick Install

pip install strands-agents-tools

To install the dependencies for optional tools:

pip install "strands-agents-tools[mem0_memory, use_browser, rss, use_computer]"

Development Install

```bash

Install in development mode

pip install -e ".[dev]"

Install pre-commit hooks

pre-commit install ```

💻 Usage Examples

For async usage, call the corresponding *_async function with await.

Synchronous usage

agent = Agent(tools=[tavily_search, tavily_extract, tavily_crawl, tavily_map])

Example usage of the batch with http_request and use_aws tools

agent = Agent(tools=[batch, http_request, use_aws])

result = agent.tool.batch( invocations=[ {"name": "http_request", "arguments": {"method": "GET", "url": "https://api.ipify.org?format=json"}}, { "name": "use_aws", "arguments": { "service_name": "s3", "operation_name": "list_buckets", "parameters": {}, "region": "us-east-1", "label": "List S3 Buckets" } }, ] ) ```

Basic usage - inherits parent agent's model

result = agent.tool.use_agent( prompt="Tell me about the advantages of tool-building in AI agents", system_prompt="You are a helpful AI assistant specializing in AI development concepts." )

Create and activate virtual environment

python3 -m venv .venv source .venv/bin/activate # On Windows: .venv\Scripts\activate

Using environment variable to set default metadata behavior

Set RETRIEVE_ENABLE_METADATA_DEFAULT=true in your environment

result = agent.tool.retrieve( text="Tell me about cloud computing" # enableMetadata will default to the environment variable value ) ```

Use environment variables to determine model

import os os.environ["STRANDS_PROVIDER"] = "ollama" os.environ["STRANDS_MODEL_ID"] = "qwen3:4b" result = agent.tool.use_agent( prompt="Analyze this code", system_prompt="You are a code review assistant.", model_provider="env" )

Custom model configuration with specific parameters

result = agent.tool.use_agent( prompt="Write a creative story", system_prompt="You are a creative writing assistant.", model_provider="github", model_settings={ "model_id": "openai/o4-mini", "params": {"temperature": 1, "max_tokens": 4000} } ) ```

Single-tenant: use the standalone tool with configuration from environment variables

agent = Agent(tools=[elasticsearch_memory]) result = agent.tool.elasticsearch_memory(action="record", content="User prefers vegetarian pizza") ```

Single-tenant: use the standalone tool with configuration from environment variables

agent = Agent(tools=[mongodb_memory]) result = agent.tool.mongodb_memory(action="record", content="User prefers vegetarian pizza") ```

🌍 Environment Variables Configuration

Agents Tools provides extensive customization through environment variables. This allows you to configure tool behavior without modifying code, making it ideal for different environments (development, testing, production).

Global Environment Variables

These variables affect multiple tools:

Tool-Specific Environment Variables

Calculator Tool

Current Time Tool

Sleep Tool

Tavily Search, Extract, Crawl, and Map Tools

Exa Search and Contents Tools

Mem0 Memory Tool

Security Model: The tenant-isolation keys (user_id / agent_id) are never exposed as agent-facing tool parameters. The agent only chooses the action and its content/query/memory_id. This prevents a model (or prompt-injected content) from reading, writing, or deleting another tenant's memories.

Usage patterns:

```python from strands import Agent from strands_tools.mem0_memory import Mem0MemoryTool, mem0_memory

Single-tenant: use the standalone function with env vars (MEM0_USER_ID / MEM0_AGENT_ID)

agent = Agent(tools=[mem0_memory]) agent.tool.mem0_memory(action="store", content="User prefers vegetarian pizza")

The Mem0 Memory Tool supports three different backend configurations:

1. **Mem0 Platform**:
   - Uses the Mem0 Platform API for memory management
   - Requires a Mem0 API key

2. **OpenSearch** (Recommended for AWS environments):
   - Uses OpenSearch as the vector store backend
   - Requires AWS credentials and OpenSearch configuration

3. **FAISS** (Default for local development):
   - Uses FAISS as the local vector store backend
   - Requires faiss-cpu package for local vector storage

4. **Neptune Analytics** (Optional Graph backend for search enhancement):
   - Uses Neptune Analytics as the graph store backend to enhance memory recall.
   - Requires AWS credentials and Neptune Analytics configuration
   

# Configure your Neptune Analytics graph ID in Python code: import os os.environ['NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER'] = "g-sample-graph-id"

```

Note: - If MEM0_API_KEY is set, the tool will use the Mem0 Platform - If OPENSEARCH_HOST is set, the tool will use OpenSearch - If neither is set, the tool will default to FAISS (requires faiss-cpu package) - If NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER is set, the tool will configure Neptune Analytics as graph store to enhance memory search - LLM configuration applies to all backend modes and allows customization of the language model used for memory processing

Bright Data Tool

Memory Tool

Nova Reels Tool

Python REPL Tool

Shell Tool

Slack Tool

Speak Tool

Editor Tool

Environment Tool

HTTP Request Tool

Dynamic MCP Client Tool

| Environment Variable | Description | Default | |----------------------|-------------|---------| | STRANDS_MCP_TIMEOUT | Default timeout in seconds for MCP operations | 30.0 |

File Read Tool

Dynamic MCP Client Integration

⚠️ SECURITY WARNING: The Dynamic MCP Client allows agents to autonomously connect to external MCP servers and load remote tools at runtime. This poses significant security risks as agents can potentially connect to malicious servers and execute untrusted code. Use with extreme caution in production environments.

This tool is different from the static MCP server implementation in the Strands SDK (see MCP Tools Documentation) which uses pre-configured, trusted MCP servers.

```python from strands import Agent from strands_tools import mcp_client

agent = Agent(tools=[mcp_client])

Create a multi-agent research pipeline

result = agent.tool.graph( action="create", graph_id="research_pipeline", topology={ "nodes": [ { "id": "researcher", "role": "researcher", "system_prompt": "You research topics thoroughly.", "model_provider": "bedrock", "model_settings": {"model_id": "us.anthropic.claude-sonnet-4-20250514-v1:0"} }, { "id": "analyst", "role": "analyst", "system_prompt": "You analyze research data.", "model_provider": "bedrock", "model_settings": {"model_id": "us.anthropic.claude-3-5-haiku-20241022-v1:0"} }, { "id": "reporter", "role": "reporter", "system_prompt": "You create comprehensive reports.", "tools": ["file_write", "editor"] } ], "edges": [ {"from": "researcher", "to": "analyst"}, {"from": "analyst", "to": "reporter"} ], "entry_points": ["researcher"] } )