Skip to main content
skill CX Codex

add-redis-iris — Claude Code skill: what it does, how to install

The add-redis-iris skill for Claude Code integrates Redis Iris into AI agents across various frameworks. Runs when the user requests to add agent memory, playbooks, or a context gateway.

MIT 110 installs ★ 178 updated 2026-09-08

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add redis/agent-skills --skill add-redis-iris -a claude-code
Open on GitHub

What add-redis-iris does

The skill inspects the codebase to locate model invocation points, detects the framework through imports, and maps missing features to Redis Iris products like Agent Memory, Context Gateway, or Intent Router. It preserves the existing agent architecture with minimal code diffs.

It handles package installation via uv, Poetry, or requirements files, then guides the configuration of iris.toml profiles for either Redis Cloud or self-managed suites.

Setup requires a Python project and package management tools. Environment variables and administrative tokens are stored in .env and .env.admin files.

What it helps with

  • detect the framework of an existing AI agent
  • add agent memory or playbooks to the project
  • configure context gateway and intent router
  • generate the iris.toml profile configuration

Example prompts for the agent

  • Add Redis Iris to this agent
  • Which Iris product does our LangGraph agent need?
  • Set up the context gateway for the project

How to install add-redis-iris

1Skills CLI (Vercel)

npx skills add redis/agent-skills --skill add-redis-iris -a claude-code

2Manually: put the files in place

~/.claude/skills/add-redis-iris/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/add-redis-iris/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about add-redis-iris

How to install add-redis-iris in Claude Code?

Run npx skills add redis/agent-skills --skill add-redis-iris -a claude-code followed by ~/.claude/skills/add-redis-iris/SKILL.md.

What does add-redis-iris do?

It inspects agent code, detects the framework, identifies missing Redis Iris components, and hooks them up with minimal changes.

What is required to run add-redis-iris?

A Python project, a package manager like uv or Poetry, and connection details for Redis Cloud or a self-managed suite.

Source text

SKILL.md · MIT
---
name: add-redis-iris
description: Add Redis Iris to an existing AI agent in any framework (LangGraph, LangChain, OpenAI Agents SDK, Google ADK, Pydantic AI, CrewAI, or a plain loop). Use when the user asks to add Iris, Redis Agent Memory, Agent Playbooks, Context Gateway, Intent Router, or Lens to their agent, or asks which Iris product their agent needs. Detects the framework and routes to the product skill.
license: MIT
metadata:
  author: redis
  version: "1.0.0"
---

# Add Redis Iris

Inspect, install, route. Do not rewrite the agent.

## 1. Find the agent

Locate:

- **The turn**: where the model is called (`invoke`, `Runner.run`, `generate_content`, `agent.run`, `kickoff`, `chat.completions.create`, `messages.create`).
- **Tool registration**: where tools are defined and handed to the model.
- **User and session ids**: where the request's user id and thread or session id live.
- **More than one loop** (a hand-written loop and a framework, or two frameworks)? Create the product objects once in a module with no framework imports, wire each loop at its own seam, and convert one loop at a time. Do not pick the loop for the user.

## 2. Detect the framework

Search imports:

| Import | Framework |
|---|---|
| `langgraph`, `langchain`, `langchain_core` | LangGraph / LangChain |
| `agents` (package `openai-agents`) | OpenAI Agents SDK |
| `google.adk` | Google ADK |
| `pydantic_ai` | Pydantic AI |
| `crewai` | CrewAI |
| only `openai`, `anthropic`, or another model client | Plain loop |

Note the version from the lockfile. Product skills look up that version's API over MCP.

## 3. Find what it lacks

| Symptom in the code | Product | Skill |
|---|---|---|
| No long-term memory, `InMemoryStore`, checkpointer only, memory in a dict or local DB | Agent Memory | `add-agent-memory` |
| Already on Redis Agent Memory through its own REST or MCP client, hand-written adapters, or model-facing memory tools | Agent Memory | `add-agent-memory`, "Already on Redis Agent Memory" |
| Policy or procedures hardcoded in the prompt, tool usage guidance in the prompt, or a vector store over policy docs | Agent Playbooks | `add-agent-playbooks` |
| A semantic response cache: model answers stored and re-served to later users, curated by hand | Agent Playbooks | `add-agent-playbooks`, "Replacing a response cache" |
| Several MCP servers configured one by one in the agent, each with its own secret, or too many tool schemas in the prompt | Context Gateway | `add-context-gateway` |
| A keyword if/else router, or an LLM call just to pick a route | Intent Router | `add-intent-router` |
| No per-turn tracing: no way to see which LLM calls, tools and retrievals one answer used, or what it cost | Lens | `add-lens` |

If the user named a product, use that. If unclear, ask once, listing what you found.

Lens goes next to any product, or on its own: it traces the turn, and every Iris product traces itself inside it. Offer it alongside whatever else you add.

## 4. Install

- `uv.lock` or `[tool.uv]` present: `uv add redis-iris`.
- Poetry: `poetry add redis-iris`.
- Otherwise add `redis-iris` to the project's requirements file.

If resolution fails on pre-releases, retry with `uv add --prerelease=allow redis-iris`. Confirm: `uv run python -c "import redis_iris; print(redis_iris.__version__)"`.

## 5. Route

Follow each chosen product skill. More than one product: each skill adds its own calls. Optionally build them from one config with `Iris.from_env()` (`iris.agent_memory()`, `iris.agent_playbooks()`, `iris.context_gateway()`, `iris.intent_router()`).

Ask once whether the services run on Redis Cloud or a self-managed suite, then write the project's `iris.toml` profile. Only the `iris` CLI reads `iris.toml`; the app reads env vars. It holds URLs only: a token in TOML makes the CLI exit 2. Select the profile with `IRIS_CONFIG=./iris.toml` and `IRIS_PROFILE=cloud` or `IRIS_PROFILE=suite`.

Redis Cloud. The person fills `.env` from the console: `IRIS_<PRODUCT>_URL`, its ID and `_API_KEY` per product.

```toml
[profiles.cloud]
kind = "cloud"
console_url = "https://cloud.redis.io"

[profiles.cloud.agent_memory]
url = "https://gcp-us-east4.memory.redis.io"  # the data-plane URL from the console
```

Self-managed suite. The operator's tokens go in `.env.admin`, never the app's `.env`; `service create --write-env .env` writes the app's `.env`.

```toml
[profiles.suite]
kind = "self-managed"

[profiles.suite.agent_memory]
service_url = "https://memory-admin.example.com"  # control plane: the CLI calls it for service create and check
url = "https://memory.example.com"  # data plane: what the agent calls
identity_url = "https://memory-identity.example.com"  # Identity Service that mints the agent's keys
```

Add one table per product the app uses: `agent_memory`, `agent_playbooks`, `context_gateway`, `intent_router`. `[profiles.suite.context_gateway]` has no `url`: `service create --write-env` writes the Gateway's endpoint. A suite with one shared Identity Service sets `[profiles.suite.identity]` `url` once instead of each `identity_url`. `IRIS_<PRODUCT>_SERVICE_URL`, `IRIS_<PRODUCT>_URL` and `IRIS_<PRODUCT>_IDENTITY_URL` override the profile.

## Rules

- Keep the user's framework, graph, and prompts. Smallest diff.
- Never guess framework APIs from memory. Look them up over MCP (see each product skill).
- Only use APIs in `redis_iris`. `redis_iris.integrations.langgraph.attach` (extra `redis-iris[langgraph]`) and `redis_iris.integrations.adk.attach` (no extra) exist; there is no `IrisTool`, `iris.tools()`, or `iris.turn()`.
- The SDK raises on a missing setting or an outage. Ask whether a product failure may fail the turn; most production agents catch it and continue with an empty block.
- Never commit secrets.

© redis · MIT · redis/agent-skills

Similar skills

All skills for AI and ML →

From the same set16

The whole set →
redis-search redis-search is a Claude Code skill for designing Redis Search indexes and writing queries. It comes into play for filters, vector retrieval, or RAG pipelines. CX Codex +1 1,900installs iris-development iris-development — a skill for Redis Agent Memory: wire an AI agent to a persistent memory store on Redis Cloud, with session events and searchable long-term records. CX Codex +1 1,700installs add-agent-memory add-agent-memory — a skill for Claude Code and Cursor that wires Redis agent memory into existing workflows for cross-session recall. CX Codex +1 113installs add-agent-playbooks The add-agent-playbooks Claude Code skill connects Redis Iris Agent Playbooks to an existing Python agent. It runs when approved answers or repeatable procedures need to move out of prompts, documents, or a semantic cache. CX Codex +1 110installs add-intent-router The add-intent-router Claude Code skill replaces keyword checks or a route-only LLM call with Redis Iris Intent Router. It kicks in when an agent needs to map messages to defined intents and dispatch targets. CX Codex +1 109installs add-context-gateway The add-context-gateway Claude Code skill routes an agent’s MCP servers through one Redis Iris Context Gateway. It activates when the agent has separate server configurations or too many tool schemas in context. CX Codex +1 107installs add-lens add-lens — a skill for Claude Code and Cursor that adds Redis Iris Lens tracing to an existing AI agent. Runs when asked to add observability or per-turn traces. CX Codex +1 106installs redis-docs-mcp redis-docs-mcp is a Claude Code skill for interpreting Redis documentation results from MCP tools. It applies before a docs lookup or when search, fetch, or ask returns something confusing. CX Codex +1 101installs

Project sponsors

Companies that keep this analytics open