langgraph-redis

Redis checkpointer and store for memory management in LangGraph

Stars: 195

Visit

LangGraph Redis is a repository containing Redis implementations for LangGraph, offering Checkpoint Savers and Stores functionality. It consists of Redis Checkpoint Savers for storing and managing checkpoints, Redis Stores for key-value stores with vector search capabilities, and Redis Middleware for semantic caching, tool caching, and conversation memory. The project has dependencies on Python packages like redis, redisvl, and langgraph-checkpoint. It requires Redis with RedisJSON and RediSearch modules for search and indexing capabilities. The repository provides detailed instructions for installation, usage of Redis Checkpoint Savers, Async Implementation, Shallow Implementations, Redis Checkpoint TTL Support, Redis Stores, and Redis Middleware for LangChain Agents. It also includes example notebooks for various use cases and implementation details on Redis module usage, indexing, TTL implementation, and contribution guidelines.

README:

LangGraph Redis

This repository contains Redis implementations for LangGraph, providing both Checkpoint Savers and Stores functionality.

Overview

The project consists of three main components:

Redis Checkpoint Savers: Implementations for storing and managing checkpoints using Redis
Redis Stores: Redis-backed key-value stores with optional vector search capabilities
Redis Middleware: LangChain agent middleware for semantic caching, tool caching, and conversation memory

Dependencies

Python Dependencies

The project requires the following main Python dependencies:

redis>=5.2.1
redisvl>=0.5.1
langgraph-checkpoint>=2.0.24

Redis Modules Requirements

IMPORTANT: This library requires Redis with the following modules:

RedisJSON - For storing and manipulating JSON data
RediSearch - For search and indexing capabilities

Redis 8.0+

If you're using Redis 8.0 or higher, both RedisJSON and RediSearch modules are included by default as part of the core Redis distribution. No additional installation is required.

Redis < 8.0

If you're using a Redis version lower than 8.0, you'll need to ensure these modules are installed:

Use Redis Stack, which bundles Redis with these modules
Or install the modules separately in your Redis instance

Failure to have these modules available will result in errors during index creation and checkpoint operations.

Azure Managed Redis / Azure Cache for Redis / Redis Enterprise Configuration

If you're using Azure Managed Redis, Azure Cache for Redis (especially Enterprise tier) or Redis Enterprise, there are important configuration considerations:

Client Configuration

Azure Managed Redis, Azure Cache for Redis and Redis Enterprise use a proxy layer that makes the cluster appear as a single endpoint. This requires using a standard Redis client, not a cluster-aware client:

from redis import Redis
from langgraph.checkpoint.redis import RedisSaver

# ✅ CORRECT: Use standard Redis client for Azure/Enterprise
client = Redis(
    host="your-cache.redis.cache.windows.net",  # or your Redis Enterprise endpoint
    port=6379,  # or 10000 for Azure Managed Redis / Azure Enterprise with TLS
    password="your-access-key",
    ssl=True,  # Azure/Enterprise typically requires SSL
    ssl_cert_reqs="required",  # or "none" for self-signed certs
    decode_responses=False  # RedisSaver expects bytes
)

# Pass the configured client to RedisSaver
saver = RedisSaver(redis_client=client)
saver.setup()

# ❌ WRONG: Don't use RedisCluster client with Azure/Enterprise
# from redis.cluster import RedisCluster
# cluster_client = RedisCluster(...)  # This will fail with proxy-based deployments

Why This Matters

Proxy Architecture: Azure Managed Redis, Azure Cache for Redis and Redis Enterprise use a proxy layer that handles cluster operations internally
Automatic Detection: RedisSaver will correctly detect this as non-cluster mode when using the standard client
No Cross-Slot Errors: The proxy handles key distribution, avoiding cross-slot errors

Azure Specific Settings

For Azure Managed Redis & Azure Cache for Redis Enterprise tier:

Port: Use port 10000 with TLS, or 6379 for standard
Modules: RediSearch and RedisJSON need to be selected at creation
SSL/TLS: Always enabled, minimum TLS 1.2

Example for Azure Managed Redis, Azure Cache for Redis Enterprise:

client = Redis(
    host="your-host-endpoint",
    port=10000,  # Enterprise TLS port
    password="your-access-key",
    ssl=True,
    ssl_cert_reqs="required",
    decode_responses=False
)

Installation

Install the library using pip:

pip install langgraph-checkpoint-redis

Redis Checkpoint Savers

Important Notes

[!IMPORTANT] When using Redis checkpointers for the first time, make sure to call .setup() method on them to create required indices. See examples below.

Standard Implementation

from langgraph.checkpoint.redis import RedisSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

with RedisSaver.from_conn_string("redis://localhost:6379") as checkpointer:
    # Call setup to initialize indices
    checkpointer.setup()
    checkpoint = {
        "v": 1,
        "ts": "2024-07-31T20:14:19.804150+00:00",
        "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
        "channel_values": {
            "my_key": "meow",
            "node": "node"
        },
        "channel_versions": {
            "__start__": 2,
            "my_key": 3,
            "start:node": 3,
            "node": 3
        },
        "versions_seen": {
            "__input__": {},
            "__start__": {
                "__start__": 1
            },
            "node": {
                "start:node": 2
            }
        },
        "pending_sends": [],
    }

    # Store checkpoint
    checkpointer.put(write_config, checkpoint, {}, {})

    # Retrieve checkpoint
    loaded_checkpoint = checkpointer.get(read_config)

    # List all checkpoints
    checkpoints = list(checkpointer.list(read_config))

Async Implementation

from langgraph.checkpoint.redis.aio import AsyncRedisSaver


async def main():
    write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
    read_config = {"configurable": {"thread_id": "1"}}

    async with AsyncRedisSaver.from_conn_string("redis://localhost:6379") as checkpointer:
        # Call setup to initialize indices
        await checkpointer.asetup()
        checkpoint = {
            "v": 1,
            "ts": "2024-07-31T20:14:19.804150+00:00",
            "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
            "channel_values": {
                "my_key": "meow",
                "node": "node"
            },
            "channel_versions": {
                "__start__": 2,
                "my_key": 3,
                "start:node": 3,
                "node": 3
            },
            "versions_seen": {
                "__input__": {},
                "__start__": {
                    "__start__": 1
                },
                "node": {
                    "start:node": 2
                }
            },
            "pending_sends": [],
        }

        # Store checkpoint
        await checkpointer.aput(write_config, checkpoint, {}, {})

        # Retrieve checkpoint
        loaded_checkpoint = await checkpointer.aget(read_config)

        # List all checkpoints
        checkpoints = [c async for c in checkpointer.alist(read_config)]


# Run the async main function
import asyncio

asyncio.run(main())

Shallow Implementations

Shallow Redis checkpoint savers store only the latest checkpoint in Redis. These implementations are useful when retaining a complete checkpoint history is unnecessary.

from langgraph.checkpoint.redis.shallow import ShallowRedisSaver

# For async version: from langgraph.checkpoint.redis.ashallow import AsyncShallowRedisSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

with ShallowRedisSaver.from_conn_string("redis://localhost:6379") as checkpointer:
    checkpointer.setup()
    # ... rest of the implementation follows similar pattern

Redis Checkpoint TTL Support

Both Redis checkpoint savers and stores support automatic expiration using Redis TTL:

# Configure automatic expiration
ttl_config = {
    "default_ttl": 60,  # Expire checkpoints after 60 minutes
    "refresh_on_read": True,  # Reset expiration time when reading checkpoints
}

with RedisSaver.from_conn_string("redis://localhost:6379", ttl=ttl_config) as saver:
    saver.setup()
    # Checkpoints will expire after 60 minutes of inactivity

When no TTL is configured, checkpoints are persistent (never expire automatically).

Removing TTL (Pinning Threads)

You can make specific checkpoints persistent by removing their TTL. This is useful for "pinning" important threads that should never expire:

from langgraph.checkpoint.redis import RedisSaver

# Create saver with default TTL
saver = RedisSaver.from_conn_string("redis://localhost:6379", ttl={"default_ttl": 60})
saver.setup()

# Save a checkpoint
config = {"configurable": {"thread_id": "important-thread", "checkpoint_ns": ""}}
saved_config = saver.put(config, checkpoint, metadata, {})

# Remove TTL from the checkpoint to make it persistent
checkpoint_id = saved_config["configurable"]["checkpoint_id"]
checkpoint_key = f"checkpoint:important-thread:__empty__:{checkpoint_id}"
saver._apply_ttl_to_keys(checkpoint_key, ttl_minutes=-1)

# The checkpoint is now persistent and won't expire

When no TTL configuration is provided, checkpoints are persistent by default (no expiration).

This makes it easy to manage storage and ensure ephemeral data is automatically cleaned up while keeping important data persistent.

Redis Stores

Redis Stores provide a persistent key-value store with optional vector search capabilities.

Synchronous Implementation

from langgraph.store.redis import RedisStore

# Basic usage
with RedisStore.from_conn_string("redis://localhost:6379") as store:
    store.setup()
    # Use the store...

# With vector search configuration
index_config = {
    "dims": 1536,  # Vector dimensions
    "distance_type": "cosine",  # Distance metric
    "fields": ["text"],  # Fields to index
}

# With TTL configuration
ttl_config = {
    "default_ttl": 60,  # Default TTL in minutes
    "refresh_on_read": True,  # Refresh TTL when store entries are read
}

with RedisStore.from_conn_string(
        "redis://localhost:6379",
        index=index_config,
        ttl=ttl_config
) as store:
    store.setup()
    # Use the store with vector search and TTL capabilities...

Async Implementation

from langgraph.store.redis.aio import AsyncRedisStore


async def main():
    # TTL also works with async implementations
    ttl_config = {
        "default_ttl": 60,  # Default TTL in minutes
        "refresh_on_read": True,  # Refresh TTL when store entries are read
    }

    async with AsyncRedisStore.from_conn_string(
            "redis://localhost:6379",
            ttl=ttl_config
    ) as store:
        await store.setup()
        # Use the store asynchronously...


asyncio.run(main())

Redis Middleware for LangChain Agents

Redis middleware provides semantic caching, tool result caching, conversation memory, and semantic routing for LangChain agents. These middleware components integrate directly with langchain.agents.create_agent().

Key Features

SemanticCacheMiddleware: Cache LLM responses by semantic similarity, reducing costs and latency
ToolResultCacheMiddleware: Cache expensive tool executions (API calls, computations)
ConversationMemoryMiddleware: Inject semantically relevant past messages into context
SemanticRouterMiddleware: Route requests based on semantic matching

Quick Start

import ast
import operator as op

from langchain.agents import create_agent
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langgraph.middleware.redis import (
    SemanticCacheMiddleware,
    SemanticCacheConfig,
    ToolResultCacheMiddleware,
    ToolCacheConfig,
)

# Safe math expression evaluator (no arbitrary code execution)
SAFE_OPERATORS = {
    ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
    ast.Div: op.truediv, ast.Pow: op.pow, ast.USub: op.neg,
}

def _eval_expr(node):
    if isinstance(node, ast.Constant):
        return node.value
    elif isinstance(node, ast.BinOp) and type(node.op) in SAFE_OPERATORS:
        return SAFE_OPERATORS[type(node.op)](_eval_expr(node.left), _eval_expr(node.right))
    elif isinstance(node, ast.UnaryOp) and type(node.op) in SAFE_OPERATORS:
        return SAFE_OPERATORS[type(node.op)](_eval_expr(node.operand))
    raise ValueError(f"Unsupported expression")

def safe_eval(expr: str) -> float:
    return _eval_expr(ast.parse(expr, mode='eval').body)

# Define tools with cacheability metadata
@tool
def calculate(expression: str) -> str:
    """Evaluate a math expression."""
    return str(safe_eval(expression))

calculate.metadata = {"cacheable": True}  # Deterministic - safe to cache

@tool
def get_stock_price(symbol: str) -> str:
    """Get current stock price."""
    return fetch_price(symbol)

get_stock_price.metadata = {"cacheable": False}  # Temporal - don't cache

# Create middleware
semantic_cache = SemanticCacheMiddleware(
    SemanticCacheConfig(
        redis_url="redis://localhost:6379",
        name="llm_cache",
        distance_threshold=0.15,
        ttl_seconds=3600,
        deterministic_tools=["calculate"],  # Safe to cache after these tools
    )
)

tool_cache = ToolResultCacheMiddleware(
    ToolCacheConfig(
        redis_url="redis://localhost:6379",
        name="tool_cache",
        ttl_seconds=1800,
    )
)

# Create agent with middleware
agent = create_agent(
    model="gpt-4o-mini",
    tools=[calculate, get_stock_price],
    middleware=[semantic_cache, tool_cache],
)

# Use async invocation (middleware is async-first)
result = await agent.ainvoke({"messages": [HumanMessage(content="Calculate 25 * 4")]})

Tool Cacheability

Control which tools are cached using LangChain's native metadata:

# Option 1: Set metadata after @tool decoration
@tool
def search(query: str) -> str:
    """Search the web."""
    return web_search(query)

search.metadata = {"cacheable": True}

# Option 2: Use StructuredTool with metadata
from langchain_core.tools import StructuredTool

get_weather = StructuredTool.from_function(
    func=fetch_weather,
    name="get_weather",
    description="Get current weather",
    metadata={"cacheable": False},  # Real-time data
)

Middleware Composition

Combine multiple middleware using MiddlewareStack or factory functions:

from langgraph.middleware.redis import MiddlewareStack, from_configs

# Option 1: Create stack directly
stack = MiddlewareStack([
    SemanticCacheMiddleware(SemanticCacheConfig(redis_url="redis://localhost:6379", name="llm_cache")),
    ToolResultCacheMiddleware(ToolCacheConfig(redis_url="redis://localhost:6379", name="tool_cache")),
])

# Option 2: Use from_configs factory (shares Redis connection)
stack = from_configs(
    configs=[
        SemanticCacheConfig(name="llm_cache", ttl_seconds=3600),
        ToolCacheConfig(name="tool_cache", ttl_seconds=1800),
    ],
    redis_url="redis://localhost:6379",
)

agent = create_agent(model="gpt-4o-mini", tools=tools, middleware=[stack])

Connection Sharing with Checkpointer

Share Redis connections between middleware and checkpointer:

from langgraph.checkpoint.redis.aio import AsyncRedisSaver
from langgraph.middleware.redis import IntegratedRedisMiddleware

# Create checkpointer
checkpointer = AsyncRedisSaver(redis_url="redis://localhost:6379")
await checkpointer.asetup()

# Create middleware that shares the connection
middleware = IntegratedRedisMiddleware.from_saver(
    checkpointer,
    configs=[
        SemanticCacheConfig(name="llm_cache"),
        ToolCacheConfig(name="tool_cache"),
    ],
)

agent = create_agent(
    model="gpt-4o-mini",
    tools=tools,
    checkpointer=checkpointer,
    middleware=[middleware],
)

Example Notebooks

See the examples/middleware/ directory for detailed notebooks:

middleware_semantic_cache.ipynb: LLM response caching with semantic matching
middleware_tool_caching.ipynb: Tool result caching with metadata-based control
middleware_conversation_memory.ipynb: Semantic conversation history retrieval
middleware_composition.ipynb: Combining middleware with checkpointers

Examples

The examples directory contains Jupyter notebooks demonstrating the usage of Redis with LangGraph:

Checkpoint and Store Examples

persistence_redis.ipynb: Demonstrates the usage of Redis checkpoint savers with LangGraph
create-react-agent-memory.ipynb: Shows how to create an agent with persistent memory using Redis
cross-thread-persistence.ipynb: Demonstrates cross-thread persistence capabilities
persistence-functional.ipynb: Shows functional persistence patterns with Redis

Middleware Examples (`examples/middleware/`)

middleware_semantic_cache.ipynb: LLM response caching with semantic similarity matching
middleware_tool_caching.ipynb: Tool result caching with metadata-based cacheability control
middleware_conversation_memory.ipynb: Semantic conversation history and context injection
middleware_composition.ipynb: Combining multiple middleware with shared Redis connections

Running Example Notebooks

To run the example notebooks with Docker:

Navigate to the examples directory:
```
cd examples
```
Start the Docker containers:
```
docker compose up
```
Open the URL shown in the console (typically http://127.0.0.1:8888/tree) in your browser to access Jupyter.
When finished, stop the containers:
```
docker compose down
```

Implementation Details

Redis Module Usage

This implementation relies on specific Redis modules:

RedisJSON: Used for storing structured JSON data as native Redis objects
RediSearch: Used for creating and querying indices on JSON data

Indexing

The Redis implementation creates these main indices using RediSearch:

Checkpoints Index: Stores checkpoint metadata and versioning
Channel Values Index: Stores channel-specific data
Writes Index: Tracks pending writes and intermediate states

For Redis Stores with vector search:

Store Index: Main key-value store
Vector Index: Optional vector embeddings for similarity search

TTL Implementation

Both Redis checkpoint savers and stores leverage Redis's native key expiration:

Native Redis TTL: Uses Redis's built-in EXPIRE command for setting TTL
TTL Removal: Uses Redis's PERSIST command to remove TTL (with ttl_minutes=-1)
Automatic Cleanup: Redis automatically removes expired keys
Configurable Default TTL: Set a default TTL for all keys in minutes
TTL Refresh on Read: Optionally refresh TTL when keys are accessed
Applied to All Related Keys: TTL is applied to all related keys (checkpoint, blobs, writes)
Persistent by Default: When no TTL is configured, keys are persistent (no expiration)

Contributing

We welcome contributions! Here's how you can help:

Development Setup

Clone the repository:

git clone https://github.com/redis-developer/langgraph-redis
cd langgraph-redis

Install dependencies:
```
`poetry install --all-extras`
```

Available Commands

The project includes several make commands for development:

Testing:

make test           # Run all tests
make test-all       # Run all tests including API tests

Linting and Formatting:

make format        # Format all files with Black and isort
make lint          # Run formatting, type checking, and other linters
make check-types   # Run mypy type checking

Code Quality:

make test-coverage    # Run tests with coverage reporting
make coverage-report  # Generate coverage report without running tests
make coverage-html    # Generate HTML coverage report (opens in htmlcov/)
make find-dead-code   # Find unused code with vulture

Redis for Development/Testing:

make redis-start   # Start Redis Stack in Docker (includes RedisJSON and RediSearch modules)
make redis-stop    # Stop Redis container

Contribution Guidelines

Create a new branch for your changes
Write tests for new functionality
Ensure all tests pass: make test
Format your code: make format
Run linting checks: make lint
Submit a pull request with a clear description of your changes
Follow Conventional Commits for commit messages

License

This project is licensed under the MIT License.

For Tasks:

Click tags to check more tools for each tasks

store and manage checkpoints implement key-value stores cache tool results route requests based on semantics create agents with persistent memory

For Jobs:

data engineer software developer ai engineer machine learning engineer cloud architect

Alternative AI tools for langgraph-redis

Similar Open Source Tools

langgraph-redis

github

: 195

redis-vl-python

The Python Redis Vector Library (RedisVL) is a tailor-made client for AI applications leveraging Redis. It enhances applications with Redis' speed, flexibility, and reliability, incorporating capabilities like vector-based semantic search, full-text search, and geo-spatial search. The library bridges the gap between the emerging AI-native developer ecosystem and the capabilities of Redis by providing a lightweight, elegant, and intuitive interface. It abstracts the features of Redis into a grammar that is more aligned to the needs of today's AI/ML Engineers or Data Scientists.

github

: 377

nexus

Nexus is a tool that acts as a unified gateway for multiple LLM providers and MCP servers. It allows users to aggregate, govern, and control their AI stack by connecting multiple servers and providers through a single endpoint. Nexus provides features like MCP Server Aggregation, LLM Provider Routing, Context-Aware Tool Search, Protocol Support, Flexible Configuration, Security features, Rate Limiting, and Docker readiness. It supports tool calling, tool discovery, and error handling for STDIO servers. Nexus also integrates with AI assistants, Cursor, Claude Code, and LangChain for seamless usage.

github

: 339

mcphost

MCPHost is a CLI host application that enables Large Language Models (LLMs) to interact with external tools through the Model Context Protocol (MCP). It acts as a host in the MCP client-server architecture, allowing language models to access external tools and data sources, maintain consistent context across interactions, and execute commands safely. The tool supports interactive conversations with Claude 3.5 Sonnet and Ollama models, multiple concurrent MCP servers, dynamic tool discovery and integration, configurable server locations and arguments, and a consistent command interface across model types.

github

: 1.6k

llm-sandbox

LLM Sandbox is a lightweight and portable sandbox environment designed to securely execute large language model (LLM) generated code in a safe and isolated manner using Docker containers. It provides an easy-to-use interface for setting up, managing, and executing code in a controlled Docker environment, simplifying the process of running code generated by LLMs. The tool supports multiple programming languages, offers flexibility with predefined Docker images or custom Dockerfiles, and allows scalability with support for Kubernetes and remote Docker hosts.

github

: 151

aiosonic

Aiosonic is a lightweight Python asyncio HTTP/WebSocket client that offers fast and efficient communication with HTTP/1.1, HTTP/2, and WebSocket protocols. It supports keepalive, connection pooling, multipart file uploads, chunked responses, timeouts, automatic decompression, redirect following, type annotations, WebSocket communication, HTTP proxy, cookie sessions, elegant cookies, and nearly 100% test coverage. It requires Python version 3.10 or higher for installation and provides a simple API for making HTTP requests and WebSocket connections. Additionally, it allows API wrapping for customizing response handling and includes a performance benchmark script for comparing its speed with other HTTP clients.

github

: 170

ai-sdk-cpp

The AI SDK CPP is a modern C++ toolkit that provides a unified, easy-to-use API for building AI-powered applications with popular model providers like OpenAI and Anthropic. It bridges the gap for C++ developers by offering a clean, expressive codebase with minimal dependencies. The toolkit supports text generation, streaming content, multi-turn conversations, error handling, tool calling, async tool execution, and configurable retries. Future updates will include additional providers, text embeddings, and image generation models. The project also includes a patched version of nlohmann/json for improved thread safety and consistent behavior in multi-threaded environments.

github

: 94

aio-pika

Aio-pika is a wrapper around aiormq for asyncio and humans. It provides a completely asynchronous API, object-oriented API, transparent auto-reconnects with complete state recovery, Python 3.7+ compatibility, transparent publisher confirms support, transactions support, and complete type-hints coverage.

github

: 1.2k

acte

Acte is a framework designed to build GUI-like tools for AI Agents. It aims to address the issues of cognitive load and freedom degrees when interacting with multiple APIs in complex scenarios. By providing a graphical user interface (GUI) for Agents, Acte helps reduce cognitive load and constraints interaction, similar to how humans interact with computers through GUIs. The tool offers APIs for starting new sessions, executing actions, and displaying screens, accessible via HTTP requests or the SessionManager class.

github

: 113

aiotdlib

aiotdlib is a Python asyncio Telegram client based on TDLib. It provides automatic generation of types and functions from tl schema, validation, good IDE type hinting, and high-level API methods for simpler work with tdlib. The package includes prebuilt TDLib binaries for macOS (arm64) and Debian Bullseye (amd64). Users can use their own binary by passing `library_path` argument to `Client` class constructor. Compatibility with other versions of the library is not guaranteed. The tool requires Python 3.9+ and users need to get their `api_id` and `api_hash` from Telegram docs for installation and usage.

github

: 96

aioshelly

Aioshelly is an asynchronous library designed to control Shelly devices. It is currently under development and requires Python version 3.11 or higher, along with dependencies like bluetooth-data-tools, aiohttp, and orjson. The library provides examples for interacting with Gen1 devices using CoAP protocol and Gen2/Gen3 devices using RPC and WebSocket protocols. Users can easily connect to Shelly devices, retrieve status information, and perform various actions through the provided APIs. The repository also includes example scripts for quick testing and usage guidelines for contributors to maintain consistency with the Shelly API.

github

: 78

aiocache

Aiocache is an asyncio cache library that supports multiple backends such as memory, redis, and memcached. It provides a simple interface for functions like add, get, set, multi_get, multi_set, exists, increment, delete, clear, and raw. Users can easily install and use the library for caching data in Python applications. Aiocache allows for easy instantiation of caches and setup of cache aliases for reusing configurations. It also provides support for backends, serializers, and plugins to customize cache operations. The library offers detailed documentation and examples for different use cases and configurations.

github

: 1.2k

firecrawl-mcp-server

Firecrawl MCP Server is a Model Context Protocol (MCP) server implementation that integrates with Firecrawl for web scraping capabilities. It supports features like scrape, crawl, search, extract, and batch scrape. It provides web scraping with JS rendering, URL discovery, web search with content extraction, automatic retries with exponential backoff, credit usage monitoring, comprehensive logging system, support for cloud and self-hosted FireCrawl instances, mobile/desktop viewport support, and smart content filtering with tag inclusion/exclusion. The server includes configurable parameters for retry behavior and credit usage monitoring, rate limiting and batch processing capabilities, and tools for scraping, batch scraping, checking batch status, searching, crawling, and extracting structured information from web pages.

github

: 116

pocketgroq

PocketGroq is a tool that provides advanced functionalities for text generation, web scraping, web search, and AI response evaluation. It includes features like an Autonomous Agent for answering questions, web crawling and scraping capabilities, enhanced web search functionality, and flexible integration with Ollama server. Users can customize the agent's behavior, evaluate responses using AI, and utilize various methods for text generation, conversation management, and Chain of Thought reasoning. The tool offers comprehensive methods for different tasks, such as initializing RAG, error handling, and tool management. PocketGroq is designed to enhance development processes and enable the creation of AI-powered applications with ease.

github

: 178

LocalAGI

LocalAGI is a powerful, self-hostable AI Agent platform that allows you to design AI automations without writing code. It provides a complete drop-in replacement for OpenAI's Responses APIs with advanced agentic capabilities. With LocalAGI, you can create customizable AI assistants, automations, chat bots, and agents that run 100% locally, without the need for cloud services or API keys. The platform offers features like no-code agents, web-based interface, advanced agent teaming, connectors for various platforms, comprehensive REST API, short & long-term memory capabilities, planning & reasoning, periodic tasks scheduling, memory management, multimodal support, extensible custom actions, fully customizable models, observability, and more.

github

: 1.6k

llm.nvim

llm.nvim is a plugin for Neovim that enables code completion using LLM models. It supports 'ghost-text' code completion similar to Copilot and allows users to choose their model for code generation via HTTP requests. The plugin interfaces with multiple backends like Hugging Face, Ollama, Open AI, and TGI, providing flexibility in model selection and configuration. Users can customize the behavior of suggestions, tokenization, and model parameters to enhance their coding experience. llm.nvim also includes commands for toggling auto-suggestions and manually requesting suggestions, making it a versatile tool for developers using Neovim.

github

: 812

For similar tasks

langgraph-redis

github

: 195

For similar jobs

sweep

Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.

github

: 7.1k

teams-ai

The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.

github

: 502

ai-guide

This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.

github

: 159

classifai

Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.

github

: 697

chatbot-ui

Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.

github

: 27.7k

BricksLLM

BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students

github

: 953

uAgents

uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.

github

: 1.3k

griptape

Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.

github

: 2.2k

langgraph-redis

README:

LangGraph Redis

Overview

Dependencies

Python Dependencies

Redis Modules Requirements

Redis 8.0+

Redis < 8.0

Azure Managed Redis / Azure Cache for Redis / Redis Enterprise Configuration

Client Configuration

Why This Matters

Azure Specific Settings

Installation

Redis Checkpoint Savers

Important Notes

Standard Implementation

Async Implementation

Shallow Implementations

Redis Checkpoint TTL Support

Removing TTL (Pinning Threads)

Redis Stores

Synchronous Implementation

Async Implementation

Redis Middleware for LangChain Agents

Key Features

Quick Start

Tool Cacheability

Middleware Composition

Connection Sharing with Checkpointer

Example Notebooks

Examples

Checkpoint and Store Examples

Middleware Examples (examples/middleware/)

Running Example Notebooks

Implementation Details

Redis Module Usage

Indexing

TTL Implementation

Contributing

Development Setup

Available Commands

Contribution Guidelines

License

For Tasks:

For Jobs:

Alternative AI tools for langgraph-redis

Similar Open Source Tools

langgraph-redis

redis-vl-python

nexus

mcphost

llm-sandbox

aiosonic

ai-sdk-cpp

aio-pika

acte

aiotdlib

aioshelly

aiocache

firecrawl-mcp-server

pocketgroq

LocalAGI

llm.nvim

For similar tasks

langgraph-redis

For similar jobs

sweep

teams-ai

ai-guide

classifai

chatbot-ui

BricksLLM

uAgents

griptape

Middleware Examples (`examples/middleware/`)