supermemory/packages/openai-sdk-python

Supermemory OpenAI Python SDK

Enhanced OpenAI Python SDK with Supermemory infinite context integration.

This package extends the official OpenAI Python SDK with Supermemory capabilities, enabling infinite context chat completions and memory management tools.

Features

• 🚀 Infinite Context: Chat completions with unlimited conversation history
• 🧠 Memory Tools: Search, add, and fetch user memories seamlessly
• 🔌 Multiple Providers: Support for OpenAI, Anthropic, Groq, and more
• 🛠 Function Calling: Built-in memory tools for OpenAI function calling
• 🔒 Type Safe: Full TypeScript-style type hints for Python
• ⚡ Async Support: Full async/await support

Installation

Install using uv (recommended):

uv add supermemory-openai

Or with pip:

pip install supermemory-openai

Quick Start

Basic Chat Completion

import asyncio
from supermemory_openai import SupermemoryOpenAI, SupermemoryInfiniteChatConfigWithProviderName

async def main():
    # Initialize client
    client = SupermemoryOpenAI(
        supermemory_api_key="your-supermemory-api-key",
        config=SupermemoryInfiniteChatConfigWithProviderName(
            provider_name="openai",
            provider_api_key="your-openai-api-key",
        )
    )
    
    # Create chat completion
    response = await client.chat_completion(
        messages=[
            {"role": "user", "content": "Hello, how are you?"}
        ],
        model="gpt-4o"
    )
    
    print(response.choices[0].message.content)

asyncio.run(main())

Using Memory Tools

import asyncio
from supermemory_openai import SupermemoryOpenAI, SupermemoryTools, SupermemoryInfiniteChatConfigWithProviderName

async def main():
    # Initialize client and tools
    client = SupermemoryOpenAI(
        supermemory_api_key="your-supermemory-api-key",
        config=SupermemoryInfiniteChatConfigWithProviderName(
            provider_name="openai", 
            provider_api_key="your-openai-api-key",
        )
    )
    
    tools = SupermemoryTools(
        api_key="your-supermemory-api-key",
        config={"project_id": "my-project"}
    )
    
    # Chat with memory tools
    response = await client.chat_completion(
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant with access to user memories."
            },
            {
                "role": "user", 
                "content": "Remember that I prefer tea over coffee"
            }
        ],
        tools=tools.get_tool_definitions(),
        model="gpt-4o"
    )
    
    print(response.choices[0].message.content)

asyncio.run(main())

Configuration

Provider Configuration

Using Provider Names

from supermemory_openai import SupermemoryInfiniteChatConfigWithProviderName

config = SupermemoryInfiniteChatConfigWithProviderName(
    provider_name="openai",  # or "anthropic", "groq", "openrouter", etc.
    provider_api_key="your-provider-api-key",
    headers={"custom-header": "value"}  # optional
)

Using Custom URLs

from supermemory_openai import SupermemoryInfiniteChatConfigWithProviderUrl

config = SupermemoryInfiniteChatConfigWithProviderUrl(
    provider_url="https://your-custom-endpoint.com/v1",
    provider_api_key="your-provider-api-key",
    headers={"custom-header": "value"}  # optional
)

Supported Providers

• openai - OpenAI API
• anthropic - Anthropic Claude
• openrouter - OpenRouter
• deepinfra - DeepInfra
• groq - Groq
• google - Google AI
• cloudflare - Cloudflare Workers AI

Memory Tools

SupermemoryTools Class

from supermemory_openai import SupermemoryTools

tools = SupermemoryTools(
    api_key="your-supermemory-api-key",
    config={
        "project_id": "my-project",  # or use container_tags
        "base_url": "https://custom-endpoint.com",  # optional
    }
)

# Search memories
result = await tools.search_memories(
    information_to_get="user preferences",
    limit=10,
    include_full_docs=True
)

# Add memory  
result = await tools.add_memory(
    memory="User prefers tea over coffee"
)

# Fetch specific memory
result = await tools.fetch_memory(
    memory_id="memory-id-here"
)

Individual Tools

from supermemory_openai import (
    create_search_memories_tool,
    create_add_memory_tool, 
    create_fetch_memory_tool
)

search_tool = create_search_memories_tool("your-api-key")
add_tool = create_add_memory_tool("your-api-key")
fetch_tool = create_fetch_memory_tool("your-api-key")

Function Calling Integration

from supermemory_openai import execute_memory_tool_calls

# After getting tool calls from OpenAI
if response.choices[0].message.tool_calls:
    tool_results = await execute_memory_tool_calls(
        api_key="your-supermemory-api-key",
        tool_calls=response.choices[0].message.tool_calls,
        config={"project_id": "my-project"}
    )
    
    # Add tool results to conversation
    messages.append(response.choices[0].message)
    messages.extend(tool_results)

API Reference

SupermemoryOpenAI

Enhanced OpenAI client with infinite context support.

Constructor

SupermemoryOpenAI(
    supermemory_api_key: str,
    config: Optional[SupermemoryInfiniteChatConfig] = None
)

Methods

• chat_completion() - Create chat completion with simplified interface
• create_chat_completion() - Create chat completion with full OpenAI parameters

SupermemoryTools

Memory management tools for function calling.

Constructor

SupermemoryTools(
    api_key: str,
    config: Optional[SupermemoryToolsConfig] = None
)

Methods

• get_tool_definitions() - Get OpenAI function definitions
• search_memories() - Search user memories
• add_memory() - Add new memory
• fetch_memory() - Fetch specific memory by ID
• execute_tool_call() - Execute individual tool call

Error Handling

try:
    response = await client.chat_completion(
        messages=[{"role": "user", "content": "Hello"}],
        model="gpt-4o"
    )
except Exception as e:
    print(f"Error: {e}")

Environment Variables

Set these environment variables for testing:

• SUPERMEMORY_API_KEY - Your Supermemory API key
• PROVIDER_API_KEY - Your AI provider API key
• PROVIDER_NAME - Provider name (default: "openai")
• PROVIDER_URL - Custom provider URL (optional)
• MODEL_NAME - Model to use (default: "gpt-4o-mini")
• SUPERMEMORY_BASE_URL - Custom Supermemory base URL (optional)

Development

Setup

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone and setup
git clone <repository-url>
cd packages/openai-sdk-python
uv sync --dev

Testing

# Run tests
uv run pytest

# Run with coverage
uv run pytest --cov=supermemory_openai

# Run specific test file
uv run pytest tests/test_infinite_chat.py

Type Checking

uv run mypy src/supermemory_openai

Formatting

uv run black src/ tests/
uv run isort src/ tests/

License

MIT License - see LICENSE file for details.

Links

• Supermemory - Infinite context memory platform
• OpenAI Python SDK - Official OpenAI Python library
• Documentation - Full API documentation