New to Claude Skills? Learn how to install them →

nousresearch on GitHub

Pinecone Research

Free

Enhance agent conversations with long-term memory.

Get this skill

Free · Opens the source repo

What Pinecone Research does

Pinecone Research provides a powerful backend for building retrieval-augmented generation (RAG) pipelines in agent-based applications. By utilizing Pinecone as a vector store, developers can persist embeddings and retrieve relevant context from past interactions, facilitating a more coherent and context-aware conversation flow. This skill is particularly beneficial for applications that require agents to maintain long-term memory across sessions, allowing for a more personalized user experience.

The skill enables users to set up a basic RAG pipeline with just a few lines of code. After installing the necessary libraries, developers can initialize Pinecone, create or connect to an index, and build a vector store from documents. This setup allows agents to retrieve relevant context from previous discussions, ensuring that conversations are informed by historical data. The ability to implement namespace-based session memory further enhances this capability, enabling the isolation of data for different sessions or users.

Best practices outlined in the documentation encourage efficient data management, such as batching upserts and using metadata filtering to tag vectors with relevant information. Additionally, users are advised to prune old memory to control costs, making the skill not only powerful but also cost-effective. The integration with LangChain simplifies the process, providing a seamless experience for developers looking to enhance their agent applications with semantic search workflows.

Overall, Pinecone Research is ideal for developers and researchers focused on building intelligent agents that can learn and adapt over time. Whether you're prototyping a new application or enhancing an existing one, this skill provides the tools necessary to create a robust memory system for agent interactions.

When to use it

Use this skill when developing agent applications that require persistent memory and context retrieval across sessions.

When not to use it

Avoid this skill if you need a general-purpose Pinecone reference for index management or if you're building production infrastructure without agent integration.

What you can build with it

Building a Conversational Agent

Developers can use Pinecone Research to create agents that remember user interactions, improving the overall experience.

Prototyping Semantic Search Workflows

Researchers can quickly prototype workflows that utilize semantic search capabilities by leveraging Pinecone's vector store.

Managing Multi-Tenant Agents

Using namespaces, developers can isolate data for different users or sessions, making it ideal for multi-tenant applications.

How to install Pinecone Research

View source

1. Install with the skills CLI

npx skills add nousresearch/hermes-agent/pinecone-research --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by nousresearch

Pinecone Research — Agent RAG & Long-Term Memory

Use Pinecone as a retrieval-augmented generation (RAG) backend for agent conversations: persist embeddings, retrieve relevant context from past sessions, and build long-term memory.

When to use this skill

Use when:

  • Building agent RAG pipelines with Pinecone as the vector store
  • Need persistent long-term memory across agent sessions
  • Combining retrieval with agent tool use
  • Researching or prototyping semantic search workflows

Use the mlops/pinecone skill instead when:

  • Need a general Pinecone reference (index management, CRUD, hybrid search)
  • Working on production infrastructure without agent integration

Quick start

Setup

pip install pinecone-client langchain-pinecone langchain-openai

Set your API key:

export PINECONE_API_KEY="your-api-key"

Basic RAG pipeline

from pinecone import Pinecone, ServerlessSpec
from langchain_pinecone import PineconeVectorStore
from langchain_openai import OpenAIEmbeddings

# Initialize Pinecone
pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Create or connect to index
index_name = "agent-memory"
if index_name not in [i.name for i in pc.list_indexes()]:
    pc.create_index(
        name=index_name,
        dimension=1536,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
    )

# Build vector store
vectorstore = PineconeVectorStore.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    index_name=index_name,
)

# Retrieve relevant context
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
results = retriever.invoke("What did the agent discuss yesterday?")

Namespace-based session memory

# Store per-session memory
vectorstore = PineconeVectorStore(
    index=pc.Index(index_name),
    embedding=OpenAIEmbeddings(),
    namespace=f"session-{session_id}",
)

# Query across all sessions (no namespace filter)
all_memory = PineconeVectorStore(
    index=pc.Index(index_name),
    embedding=OpenAIEmbeddings(),
)
results = all_memory.similarity_search("relevant query", k=10)

Best practices

  1. Namespace by session or user — isolate data for multi-tenant agents
  2. Batch upserts — 100–200 vectors per batch for efficiency
  3. Metadata filtering — tag vectors with session ID, timestamp, topic
  4. Prune old memory — delete stale namespaces to control costs
  5. Use serverless — auto-scaling, pay-per-use pricing

Resources

Frequently asked questions about Pinecone Research

Similar skills