tools

Strands Agents Tools is a community-driven project that provides a powerful set of tools for your agents to use. It bridges the gap between large language models and practical applications by offering ready-to-use tools for file operations, system execution, API interactions, mathematical operations, and more.

✨ Features

• 📁 File Operations - Read, write, and edit files with syntax highlighting and intelligent modifications
• 🖥️ Shell Integration - Execute and interact with shell commands securely
• 🧠 Memory - Store user and agent memories across agent runs to provide personalized experiences with both Mem0, Amazon Bedrock Knowledge Bases, Elasticsearch, and MongoDB Atlas
• 🕸️ Web Infrastructure - Perform web searches, extract page content, and crawl websites with Tavily and Exa-powered tools
• 🌐 HTTP Client - Make API requests with comprehensive authentication support
• 💬 Slack Client - Real-time Slack events, message processing, and Slack API access
• 🐍 Python Execution - Run Python code snippets with state persistence, user confirmation for code execution, and safety features
• 🧮 Mathematical Tools - Perform advanced calculations with symbolic math capabilities
• ☁️ AWS Integration - Seamless access to AWS services
• 🖼️ Image Processing - Generate and process images for AI applications
• 🎥 Video Processing - Use models and agents to generate dynamic videos
• 🎙️ Audio Output - Enable models to generate audio and speak
• 🔄 Environment Management - Handle environment variables safely
• 📝 Journaling - Create and manage structured logs and journals
• ⏱️ Task Scheduling - Schedule and manage cron jobs
• 🧠 Advanced Reasoning - Tools for complex thinking and reasoning capabilities
• 🐝 Swarm Intelligence - Coordinate multiple AI agents for parallel problem solving with shared memory
• 🤖 Agent as Tool - Create nested agent instances with model switching support for multi-model workflows and specialized sub-tasks
• 🔗 Multi-Agent Graph - Create and manage deterministic DAG-based multi-agent pipelines with output propagation and per-node model configuration
• 🔌 Dynamic MCP Client - ⚠️ Dynamically connect to external MCP servers and load remote tools (use with caution - see security warnings)
• 🔄 Multiple tools in Parallel - Call multiple other tools at the same time in parallel with Batch Tool
• 🔍 Browser Tool - Tool giving an agent access to perform automated actions on a browser (chromium)
• 📈 Diagram - Create AWS cloud diagrams, basic diagrams, or UML diagrams using python libraries
• 📰 RSS Feed Manager - Subscribe, fetch, and process RSS feeds with content filtering and persistent storage
• 🖱️ Computer Tool - Automate desktop actions including mouse movements, keyboard input, screenshots, and application management

📦 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

# Clone the repository
git clone https://github.com/strands-agents/tools.git
cd tools

# Create and activate virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: venv\Scripts\activate

# Install in development mode
pip install -e ".[dev]"

# Install pre-commit hooks
pre-commit install

Tools Overview

Below is a comprehensive table of all available tools, how to use them with an agent, and typical use cases:

* These tools do not work on windows

💻 Usage Examples

File Operations

from strands import Agent
from strands_tools import file_read, file_write, editor

agent = Agent(tools=[file_read, file_write, editor])

agent.tool.file_read(path="config.json")
agent.tool.file_write(path="output.txt", content="Hello, world!")
agent.tool.editor(command="view", path="script.py")

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.

from strands import Agent
from strands_tools import mcp_client

agent = Agent(tools=[mcp_client])

# Connect to a custom MCP server via stdio
agent.tool.mcp_client(
    action="connect",
    connection_id="my_tools",
    transport="stdio",
    command="python",
    args=["my_mcp_server.py"]
)

# List available tools on the server
tools = agent.tool.mcp_client(
    action="list_tools",
    connection_id="my_tools"
)

# Call a tool from the MCP server
result = agent.tool.mcp_client(
    action="call_tool",
    connection_id="my_tools",
    tool_name="calculate",
    tool_args={"x": 10, "y": 20}
)

# Connect to a SSE-based server
agent.tool.mcp_client(
    action="connect",
    connection_id="web_server",
    transport="sse",
    server_url="http://localhost:8080/sse"
)

# Connect to a streamable HTTP server
agent.tool.mcp_client(
    action="connect",
    connection_id="http_server",
    transport="streamable_http",
    server_url="https://api.example.com/mcp",
    headers={"Authorization": "Bearer token"},
    timeout=60
)

# Load MCP tools into agent's registry for direct access
# ⚠️ WARNING: This loads external tools directly into the agent
agent.tool.mcp_client(
    action="load_tools",
    connection_id="my_tools"
)
# Now you can call MCP tools directly as: agent.tool.calculate(x=10, y=20)

Shell Commands

Note: shell does not work on Windows.

from strands import Agent
from strands_tools import shell

agent = Agent(tools=[shell])

# Execute a single command
result = agent.tool.shell(command="ls -la")

# Execute a sequence of commands
results = agent.tool.shell(command=["mkdir -p test_dir", "cd test_dir", "touch test.txt"])

# Execute commands with error handling
agent.tool.shell(command="risky-command", ignore_errors=True)

HTTP Requests

from strands import Agent
from strands_tools import http_request

agent = Agent(tools=[http_request])

# Make a simple GET request
response = agent.tool.http_request(
    method="GET",
    url="https://api.example.com/data"
)

# POST request with authentication
response = agent.tool.http_request(
    method="POST",
    url="https://api.example.com/resource",
    headers={"Content-Type": "application/json"},
    body=json.dumps({"key": "value"}),
    auth_type="Bearer",
    auth_token="your_token_here"
)

# Convert HTML webpages to markdown for better readability
response = agent.tool.http_request(
    method="GET",
    url="https://example.com/article",
    convert_to_markdown=True
)

Tavily Search, Extract, Crawl, and Map

from strands import Agent
from strands_tools.tavily import (
    tavily_search, tavily_extract, tavily_crawl, tavily_map
)

# For async usage, call the corresponding *_async function with await.
# Synchronous usage 
agent = Agent(tools=[tavily_search, tavily_extract, tavily_crawl, tavily_map])

# Real-time web search
result = agent.tool.tavily_search(
    query="Latest developments in renewable energy",
    search_depth="advanced",
    topic="news",
    max_results=10,
    include_raw_content=True
)

# Extract content from multiple URLs
result = agent.tool.tavily_extract(
    urls=["www.tavily.com", "www.apple.com"],
    extract_depth="advanced",
    format="markdown"
)

# Advanced crawl with instructions and filtering
result = agent.tool.tavily_crawl(
    url="www.tavily.com",
    max_depth=2,
    limit=50,
    instructions="Find all API documentation and developer guides",
    extract_depth="advanced",
    include_images=True
)

# Basic website mapping
result = agent.tool.tavily_map(url="www.tavily.com")

Exa Search and Contents

from strands import Agent
from strands_tools.exa import exa_search, exa_get_contents

agent = Agent(tools=[exa_search, exa_get_contents])

# Basic search (auto mode is default and recommended)
result = agent.tool.exa_search(
    query="Best project management software",
    text=True
)

# Company-specific search when needed
result = agent.tool.exa_search(
    query="Anthropic AI safety research",
    category="company",
    include_domains=["anthropic.com"],
    num_results=5,
    summary={"query": "key research areas and findings"}
)

# News search with date filtering
result = agent.tool.exa_search(
    query="AI regulation policy updates",
    category="news",
    start_published_date="2024-01-01T00:00:00.000Z",
    text=True
)

# Get detailed content from specific URLs
result = agent.tool.exa_get_contents(
    urls=[
        "https://example.com/blog-post",
        "https://github.com/microsoft/semantic-kernel"
    ],
    text={"maxCharacters": 5000, "includeHtmlTags": False},
    summary={
        "query": "main points and practical applications"
    },
    subpages=2,
    extras={"links": 5, "imageLinks": 2}
)

# Structured summary with JSON schema
result = agent.tool.exa_get_contents(
    urls=["https://example.com/article"],
    summary={
        "query": "main findings and recommendations",
        "schema": {
            "type": "object",
            "properties": {
                "main_points": {"type": "string", "description": "Key points from the article"},
                "recommendations": {"type": "string", "description": "Suggested actions or advice"},
                "conclusion": {"type": "string", "description": "Overall conclusion"},
                "relevance": {"type": "string", "description": "Why this matters"}
            },
            "required": ["main_points", "conclusion"]
        }
    }
)

Python Code Execution

Note: python_repl does not work on Windows.

from strands import Agent
from strands_tools import python_repl

agent = Agent(tools=[python_repl])

# Execute Python code with state persistence
result = agent.tool.python_repl(code="""
import pandas as pd

# Load and process data
data = pd.read_csv('data.csv')
processed = data.groupby('category').mean()

processed.head()
""")

Code Interpreter

from strands import Agent
from strands_tools.code_interpreter import AgentCoreCodeInterpreter

# Create the code interpreter tool
bedrock_agent_core_code_interpreter = AgentCoreCodeInterpreter(region="us-west-2")
agent = Agent(tools=[bedrock_agent_core_code_interpreter.code_interpreter])

# Create a session
agent.tool.code_interpreter({
    "action": {
        "type": "initSession",
        "description": "Data analysis session",
        "session_name": "analysis-session"
    }
})

# Execute Python code
agent.tool.code_interpreter({
    "action": {
        "type": "executeCode",
        "session_name": "analysis-session",
        "code": "print('Hello from sandbox!')",
        "language": "python"
    }
})

Swarm Intelligence

from strands import Agent
from strands_tools import swarm

agent = Agent(tools=[swarm])

# Create a collaborative swarm of agents to tackle a complex problem
result = agent.tool.swarm(
    task="Generate creative solutions for reducing plastic waste in urban areas",
    swarm_size=5,
    coordination_pattern="collaborative"
)

# Create a competitive swarm for diverse solution generation
result = agent.tool.swarm(
    task="Design an innovative product for smart home automation",
    swarm_size=3,
    coordination_pattern="competitive"
)

# Hybrid approach combining collaboration and competition
result = agent.tool.swarm(
    task="Develop marketing strategies for a new sustainable fashion brand",
    swarm_size=4,
    coordination_pattern="hybrid"
)

Use AWS

from strands import Agent
from strands_tools import use_aws

agent = Agent(tools=[use_aws])

# List S3 buckets
result = agent.tool.use_aws(
    service_name="s3",
    operation_name="list_buckets",
    parameters={},
    region="us-east-1",
    label="List all S3 buckets"
)

# Get the contents of a specific S3 bucket
result = agent.tool.use_aws(
    service_name="s3",
    operation_name="list_objects_v2",
    parameters={"Bucket": "example-bucket"},  # Replace with your actual bucket name
    region="us-east-1",
    label="List objects in a specific S3 bucket"
)

# Get the list of EC2 subnets
result = agent.tool.use_aws(
    service_name="ec2",
    operation_name="describe_subnets",
    parameters={},
    region="us-east-1",
    label="List all subnets"
)

Retrieve Tool

from strands import Agent
from strands_tools import retrieve

agent = Agent(tools=[retrieve])

# Basic retrieval without metadata
result = agent.tool.retrieve(
    text="What is artificial intelligence?"
)

# Retrieval with metadata enabled
result = agent.tool.retrieve(
    text="What are the latest developments in machine learning?",
    enableMetadata=True
)

# 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
)

Batch Tool

import os
import sys

from strands import Agent
from strands_tools import batch, http_request, use_aws

# 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"
            }
        },
    ]
)

Video Tools

from strands import Agent
from strands_tools import search_video, chat_video

agent = Agent(tools=[search_video, chat_video])

# Search for video content using natural language
result = agent.tool.search_video(
    query="people discussing AI technology",
    threshold="high",
    group_by="video",
    page_limit=5
)

# Chat with existing video (no index_id needed)
result = agent.tool.chat_video(
    prompt="What are the main topics discussed in this video?",
    video_id="existing-video-id"
)

# 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
)

AgentCore Memory

from strands import Agent
from strands_tools.agent_core_memory import AgentCoreMemoryToolProvider


provider = AgentCoreMemoryToolProvider(
    memory_id="memory-123abc",  # Required
    actor_id="user-456",        # Required
    session_id="session-789",   # Required
    namespace="default",        # Required
    region="us-west-2"          # Optional, defaults to us-west-2
)

agent = Agent(tools=provider.tools)

# Create a new memory
result = agent.tool.agent_core_memory(
    action="record",
    content="I am allergic to shellfish"
)

# Search for relevant memories
result = agent.tool.agent_core_memory(
    action="retrieve",
    query="user preferences"
)

# List all memories
result = agent.tool.agent_core_memory(
    action="list"
)

# Get a specific memory by ID
result = agent.tool.agent_core_memory(
    action="get",
    memory_record_id="mr-12345"
)

Browser

from strands import Agent
from strands_tools.browser import LocalChromiumBrowser

# Create browser tool
browser = LocalChromiumBrowser()
agent = Agent(tools=[browser.browser])

# Simple navigation
result = agent.tool.browser({
    "action": {
        "type": "navigate",
        "url": "https://example.com"
    }
})

# Initialize a session first
result = agent.tool.browser({
    "action": {
        "type": "initSession",
        "session_name": "main-session",
        "description": "Web automation session"
    }
})

Handoff to User

from strands import Agent
from strands_tools import handoff_to_user

agent = Agent(tools=[handoff_to_user])

# Request user confirmation and continue
response = agent.tool.handoff_to_user(
    message="I need your approval to proceed with deleting these files. Type 'yes' to confirm.",
    breakout_of_loop=False
)

# Complete handoff to user (stops agent execution)
agent.tool.handoff_to_user(
    message="Task completed. Please review the results and take any necessary follow-up actions.",
    breakout_of_loop=True
)

Use Agent (Agent as Tool)

from strands import Agent
from strands_tools import use_agent

agent = Agent(tools=[use_agent])

# 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."
)

# Use a different model provider for specialized tasks
result = agent.tool.use_agent(
    prompt="Calculate 2 + 2 and explain the result",
    system_prompt="You are a helpful math assistant.",
    model_provider="bedrock",
    model_settings={
        "model_id": "us.anthropic.claude-sonnet-4-20250514-v1:0"
    },
    tools=["calculator"]
)

# 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}
    }
)

A2A Client

from strands import Agent
from strands_tools.a2a_client import A2AClientToolProvider

# Initialize the A2A client provider with known agent URLs
provider = A2AClientToolProvider(known_agent_urls=["http://localhost:9000"])
agent = Agent(tools=provider.tools)

# Use natural language to interact with A2A agents
response = agent("discover available agents and send a greeting message")

# The agent will automatically use the available tools:
# - discover_agent(url) to find agents
# - list_discovered_agents() to see all discovered agents
# - send_message(message_text, target_agent_url) to communicate

Diagram

from strands import Agent
from strands_tools import diagram

agent = Agent(tools=[diagram])

# Create an AWS cloud architecture diagram
result = agent.tool.diagram(
    diagram_type="cloud",
    nodes=[
        {"id": "users", "type": "Users", "label": "End Users"},
        {"id": "cloudfront", "type": "CloudFront", "label": "CDN"},
        {"id": "s3", "type": "S3", "label": "Static Assets"},
        {"id": "api", "type": "APIGateway", "label": "API Gateway"},
        {"id": "lambda", "type": "Lambda", "label": "Backend Service"}
    ],
    edges=[
        {"from": "users", "to": "cloudfront"},
        {"from": "cloudfront", "to": "s3"},
        {"from": "users", "to": "api"},
        {"from": "api", "to": "lambda"}
    ],
    title="Web Application Architecture"
)

# Create a UML class diagram
result = agent.tool.diagram(
    diagram_type="class",
    elements=[
        {
            "name": "User",
            "attributes": ["+id: int", "-name: string", "#email: string"],
            "methods": ["+login(): bool", "+logout(): void"]
        },
        {
            "name": "Order",
            "attributes": ["+id: int", "-items: List", "-total: float"],
            "methods": ["+addItem(item): void", "+calculateTotal(): float"]
        }
    ],
    relationships=[
        {"from": "User", "to": "Order", "type": "association", "multiplicity": "1..*"}
    ],
    title="E-commerce Domain Model"
)

RSS Feed Management

from strands import Agent
from strands_tools import rss

agent = Agent(tools=[rss])

# Subscribe to a feed
result = agent.tool.rss(
    action="subscribe",
    url="https://news.example.com/rss/technology"
)

# List all subscribed feeds
feeds = agent.tool.rss(action="list")

# Read entries from a specific feed
entries = agent.tool.rss(
    action="read",
    feed_id="news_example_com_technology",
    max_entries=5,
    include_content=True
)

# Search across all feeds
search_results = agent.tool.rss(
    action="search",
    query="machine learning",
    max_entries=10
)

# Fetch feed content without subscribing
latest_news = agent.tool.rss(
    action="fetch",
    url="https://blog.example.org/feed",
    max_entries=3
)

Use Computer

from strands import Agent
from strands_tools import use_computer

agent = Agent(tools=[use_computer])

# Find mouse position
result = agent.tool.use_computer(action="mouse_position")

# Automate adding text
result = agent.tool.use_computer(action="type", text="Hello, world!", app_name="Notepad")

# Analyze current computer screen
result = agent.tool.use_computer(action="analyze_screen")

result = agent.tool.use_computer(action="open_app", app_name="Calculator")
result = agent.tool.use_computer(action="close_app", app_name="Calendar")

result = agent.tool.use_computer(
    action="hotkey",
    hotkey_str="command+ctrl+f",  # For macOS
    app_name="Chrome"
)

Graph (Multi-Agent DAG)

Create deterministic DAG-based multi-agent pipelines where agents are nodes with dependency relationships. Unlike agent_graph (which uses persistent message-passing), graph uses task-based execution with output propagation.

from strands import Agent
from strands_tools.graph import graph

agent = Agent(tools=[graph])

# 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"]
    }
)

# Execute a task through the graph
result = agent.tool.graph(
    action="execute",
    graph_id="research_pipeline",
    task="Research and analyze the impact of AI on healthcare"
)

# Get graph status
result = agent.tool.graph(action="status", graph_id="research_pipeline")

# List all graphs
result = agent.tool.graph(action="list")

# Delete a graph
result = agent.tool.graph(action="delete", graph_id="research_pipeline")

Elasticsearch Memory

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

from strands import Agent
from strands_tools.elasticsearch_memory import ElasticsearchMemoryTool, elasticsearch_memory

# Bind connection, index, and namespace per principal (kept out of the agent-facing tool)
memory_tool = ElasticsearchMemoryTool(
    cloud_id="your-elasticsearch-cloud-id",  # or es_url="https://...:443" for Serverless
    api_key="your-api-key",
    index_name="memories",
    namespace="user_123",
)
agent = Agent(tools=[memory_tool.elasticsearch_memory])

# Store a memory with semantic embeddings
result = agent.tool.elasticsearch_memory(
    action="record",
    content="User prefers vegetarian pizza with extra cheese",
    metadata={"category": "food_preferences", "type": "dietary"},
)

# Search memories using semantic similarity (vector search)
result = agent.tool.elasticsearch_memory(
    action="retrieve",
    query="food preferences and dietary restrictions",
    max_results=5,
)

# List all memories with pagination
result = agent.tool.elasticsearch_memory(action="list", max_results=10)

# Get specific memory by ID
result = agent.tool.elasticsearch_memory(action="get", memory_id="mem_1234567890_abcd1234")

# Delete a memory
result = agent.tool.elasticsearch_memory(action="delete", memory_id="mem_1234567890_abcd1234")

# 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")

MongoDB Atlas Memory

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

from strands import Agent
from strands_tools.mongodb_memory import MongoDBMemoryTool, mongodb_memory

# Bind connection, collection, and namespace per principal (kept out of the agent-facing tool)
memory_tool = MongoDBMemoryTool(
    cluster_uri="mongodb+srv://username:password@cluster0.mongodb.net/?retryWrites=true&w=majority",
    database_name="memories",
    collection_name="user_memories",
    namespace="user_123",
)
agent = Agent(tools=[memory_tool.mongodb_memory])

# Store a memory with semantic embeddings
result = agent.tool.mongodb_memory(
    action="record",
    content="User prefers vegetarian pizza with extra cheese",
    metadata={"category": "food_preferences", "type": "dietary"},
)

# Search memories using semantic similarity (vector search)
result = agent.tool.mongodb_memory(
    action="retrieve",
    query="food preferences and dietary restrictions",
    max_results=5,
)

# List all memories with pagination
result = agent.tool.mongodb_memory(action="list", max_results=10)

# Get specific memory by ID
result = agent.tool.mongodb_memory(action="get", memory_id="mem_1234567890_abcd1234")

# Delete a memory
result = agent.tool.mongodb_memory(action="delete", memory_id="mem_1234567890_abcd1234")

# 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

• Visit https://www.tavily.com/ to create a free account and API key.

Exa Search and Contents Tools

• Visit https://dashboard.exa.ai/api-keys to create a free account and API key.

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:

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

# Multi-tenant (recommended): bind identity per authenticated principal
tool = Mem0MemoryTool(user_id=f"user_{authenticated_user_id}")
agent = Agent(tools=[tool.mem0_memory])
agent.tool.mem0_memory(action="store", content="User prefers vegetarian pizza")

# 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 the .env file:
   export NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER=sample-graph-id
   
   # 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

File Read Tool

Browser Tool

RSS Tool

Retrieve Tool

Use Agent Tool

Elasticsearch Memory Tool

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

Graph Tool

The graph tool uses the same model provider environment variables as use_agent for per-node model configuration. No additional environment variables are required.

Video Tools

MongoDB Atlas Memory Tool

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

Contributing ❤️

This is a community-driven project, powered by passionate developers like you. We enthusiastically welcome contributions from everyone, regardless of experience level—your unique perspective is valuable to us!

How to Get Started?

1. Find your first opportunity: If you're new to the project, explore our labeled "good first issues" for beginner-friendly tasks.
2. Understand our workflow: Review our Contributing Guide to learn about our development setup, coding standards, and pull request process.
3. Make your impact: Contributions come in many forms—fixing bugs, enhancing documentation, improving performance, adding features, writing tests, or refining the user experience.
4. Submit your work: When you're ready, submit a well-documented pull request, and our maintainers will provide feedback to help get your changes merged.

Your questions, insights, and ideas are always welcome!

Together, we're building something meaningful that impacts real users. We look forward to collaborating with you!

Stay in touch with the team

Come meet the Strands team and other users on Discord

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Security

See CONTRIBUTING for more information.