
Pinecone Research
FreeEnhance agent conversations with long-term memory.
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 source1. Install with the skills CLI
npx skills add nousresearch/hermes-agent/pinecone-research --agent claude-code2. 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 nousresearchPinecone 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
- Namespace by session or user — isolate data for multi-tenant agents
- Batch upserts — 100–200 vectors per batch for efficiency
- Metadata filtering — tag vectors with session ID, timestamp, topic
- Prune old memory — delete stale namespaces to control costs
- Use serverless — auto-scaling, pay-per-use pricing
Resources
- Pinecone Docs: https://docs.pinecone.io
- LangChain Integration: https://python.langchain.com/docs/integrations/vectorstores/pinecone
- Free Tier: 1 index, 100K vectors (1536 dimensions)
Frequently asked questions about Pinecone Research
Similar skills
Mini Context Graph
Build a persistent knowledge base with structured retrieval.
Pinecone RAG
Build RAG pipelines with Pinecone as your vector database.
Amazon Bedrock
Build generative AI applications on AWS Bedrock.
Supermemory
Enhance AI agents with persistent memory and context.
RAG Implementation
Build knowledge-grounded AI systems with RAG.
Memory Management
Enhance learning and knowledge sharing with persistent memory.
