OpenAI Agents SDK

Give your OpenAI Agents SDK agents structured memory that persists across sessions.

Why Use This Integration

Persistent Memory: Knowledge survives agent restarts and session boundaries
Advanced Retrieval: Natural language queries backed by graph + vector search
Sessionized tools: Built in session data organization in memory
Native SDK Tools: Works directly with OpenAI’s function_tool pattern
Async-First: Built for high-performance applications with proper concurrency handling

Installation

pip install cognee-integration-openai-agents

Quick Start

Configure your environment variables:

export OPENAI_API_KEY="your-openai-api-key-here"  # for OpenAI Agents SDK
export LLM_API_KEY="your-openai-api-key-here"     # for cognee

Add memory tools to your agent:

import asyncio
from agents import Agent, Runner
from cognee_integration_openai_agents import add_tool, search_tool

async def main():
    # Create agent with memory
    agent = Agent(
        name="assistant",
        instructions="You are a helpful assistant with access to a knowledge base.",
        tools=[add_tool, search_tool],
    )

    # Store information
    await Runner.run(
        agent,
        "Remember: Acme Corp, healthcare, $1.2M contract"
    )

    # Retrieve information
    result = await Runner.run(
        agent,
        "What healthcare contracts do we have?"
    )
    print(result.final_output)

asyncio.run(main())

Cross-Session Persistence

Memory persists across different agent instances:

from agents import Agent, Runner
from cognee_integration_openai_agents import get_sessionized_cognee_tools

# Session 1: Store information
add_tool, search_tool = get_sessionized_cognee_tools("user-123")

agent_1 = Agent(
    name="assistant",
    instructions="You are a helpful assistant.",
    tools=[add_tool, search_tool],
)
await Runner.run(agent_1, "I'm working on authentication")

# Session 2: Different instance, same memory
add_tool, search_tool = get_sessionized_cognee_tools("user-123")

agent_2 = Agent(
    name="assistant",
    instructions="You are a helpful assistant.",
    tools=[add_tool, search_tool],
)
result = await Runner.run(agent_2, "What was I working on?")
# Returns: "authentication"

Custom Session Management

Control session isolation with custom session IDs:

# User-specific memory
add_tool, search_tool = get_sessionized_cognee_tools(session_id="user_123")

# Org-specific memory
add_tool, search_tool = get_sessionized_cognee_tools(session_id="org_acme")

# Generate unique session automatically
add_tool, search_tool = get_sessionized_cognee_tools()  # Uses UUID-based session ID

Sessionized tools scope data to their session ID. Use non-sessionized add_tool and search_tool to access data across all sessions.

How It Works

Add Tool: Stores data in cognee’s knowledge graph with embeddings
Search Tool: Retrieves relevant information via cognee’s recall pipeline
Auto-Processing: cognee extracts entities, relationships, and context automatically
Session Scoping: Sessionized tools filter by session; non-sessionized tools access everything

Use Cases

Knowledge Accumulation

Pre-load documents into cognee before creating agents:

import cognee
from agents import Agent, Runner
from cognee_integration_openai_agents import search_tool

# Pre-load documents
for doc_path in document_paths:
    with open(doc_path, 'r') as f:
        await cognee.remember(f.read())

# Query across all documents
agent = Agent(
    name="analyst",
    instructions="You have access to our knowledge base.",
    tools=[search_tool]
)
result = await Runner.run(agent, "Find information about contract terms")

Context-Aware Assistance

Maintain user context across work sessions:

# Monday
await Runner.run(agent, "Debugging payment flow")

# Wednesday
result = await Runner.run(agent, "What was I debugging?")

Multi-Tenant Applications

Isolate data per user or organization:

add_tool, search_tool = get_sessionized_cognee_tools(session_id=user_id)

agent = Agent(
    name="assistant",
    instructions="You are a helpful assistant.",
    tools=[add_tool, search_tool]
)

Multi-Agent Workflows

Share knowledge between specialized agents:

from cognee_integration_openai_agents import add_tool, search_tool

# Data collector agent
data_agent = Agent(
    name="data_collector",
    instructions="You collect and store important information.",
    tools=[add_tool]
)

# Research agent
research_agent = Agent(
    name="researcher",
    instructions="You search and analyze the knowledge base.",
    tools=[search_tool]
)

Agent Handoffs

Route requests to specialized agents with shared memory:

storage_agent = Agent(
    name="storage_specialist",
    instructions="You specialize in storing information.",
    tools=[add_tool]
)

search_agent = Agent(
    name="search_specialist", 
    instructions="You specialize in finding information.",
    tools=[search_tool]
)

triage_agent = Agent(
    name="triage",
    instructions="Route to storage_specialist for saving, search_specialist for queries.",
    handoffs=[storage_agent, search_agent]
)

result = await Runner.run(triage_agent, "Find our healthcare contracts")

GitHub Repository

View source code and examples

Example Notebook

Step-by-step tutorial with demos

Overview

Cloud LLM Providers

Observability

Evaluation

Data Ingestion

Agent Frameworks

Coding Agents

No-Code & Low-Code

Team Chat

Why Use This Integration

Installation

Quick Start

Cross-Session Persistence

Custom Session Management

How It Works

Use Cases

GitHub Repository

Example Notebook

​Why Use This Integration

​Installation

​Quick Start

​Cross-Session Persistence

​Custom Session Management

​How It Works

​Use Cases

GitHub Repository

Example Notebook

Why Use This Integration

Installation

Quick Start

Cross-Session Persistence

Custom Session Management

How It Works

Use Cases