Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.maximem.ai/llms.txt

Use this file to discover all available pages before exploring further.

Think of organizational context as the “product brain” — the universal knowledge base that every user benefits from, regardless of which customer organization they belong to. It is the shared floor of knowledge beneath all customer-specific and user-specific memories.

​
When to use organizational context

Organizational context is the right choice when the knowledge applies universally across your application:

Product documentation

Feature descriptions, API references, usage guides, and how-to articles. Ensures your agent can answer product questions accurately for any user.

Changelog and announcements

Release notes, new features, deprecations, and migration guides. Keeps your agent up to date with product changes.

Global policies

Terms of service, privacy policies, SLA definitions, and compliance requirements. Ensures consistent, accurate policy answers.

Domain knowledge

Industry terminology, best practices, and reference material specific to your product’s domain.

​
How to ingest organizational context

Organizational context is created by ingesting documents without specifying user_id or customer_id. This causes Synap to store the resulting memories at the Client scope.

​
Via the SDK

from maximem_synap import MaximemSynapSDK

sdk = MaximemSynapSDK(api_key="your_api_key")

# Ingest a single product document
await sdk.memories.create(
    document="""
    # Acme Corp Support Escalation Policy

    Support requests are handled according to the following policy:

    - Tier 1 issues are acknowledged within one business day
    - Tier 2 issues are routed to a specialist within four hours
    - Tier 3 (critical) issues page the on-call engineer immediately

    All escalations are logged in the shared support tracker, and the
    owning team is responsible for posting a resolution summary once
    the issue is closed.
    """,
    document_type="document"
    # No user_id or customer_id -- stored at CLIENT scope
)

​
Bulk loading with the batch API

For initial product knowledge bootstrap or large documentation sets, use the batch API to ingest multiple documents in a single request: 
from maximem_synap import CreateMemoryRequest

# Bulk load product documentation at startup
documents = [
    CreateMemoryRequest(
        document=open("docs/api-reference.md").read(),
        document_type="document",
    ),
    CreateMemoryRequest(
        document=open("docs/changelog-v3.md").read(),
        document_type="document",
    ),
    CreateMemoryRequest(
        document=open("docs/pricing.md").read(),
        document_type="document",
    ),
    CreateMemoryRequest(
        document=open("docs/security-whitepaper.md").read(),
        document_type="document",
    ),
]

# Batch ingest -- all stored at CLIENT scope
await sdk.memories.batch_create(documents=documents)
Batch ingestion is the recommended approach for loading product documentation. It is more efficient than individual calls and ensures all documents are processed as a cohesive set for better entity resolution across documents.

​
How to retrieve organizational context

Organizational context can be retrieved directly or as part of the scope chain during user conversations.

​
Direct retrieval (client scope only)

Use direct retrieval when you need only organizational context — for example, to pre-populate an FAQ or verify product information: 
# Retrieve organizational context directly
context = await sdk.client.context.fetch(
    search_query=["rate limits", "pricing tiers"]
)

# context.facts might include:
# - "Free tier: 100 requests per minute"
# - "Pro tier: 1,000 requests per minute"
# - "Enterprise tier: 10,000 requests per minute"

​
As part of the scope chain

More commonly, organizational context surfaces automatically during user conversations. When you retrieve context for a specific user and customer, Synap searches the full scope chain and includes relevant Client-scoped memories alongside user-specific and customer-specific ones: 
# User asks about rate limits during a conversation
context = await sdk.user.context.fetch(
    user_id="user_alice",
    customer_id="acme_corp",
    search_query=["what are the API rate limits"]
)

# Results may include memories from all scopes:
# USER scope:    "Alice has exceeded rate limits twice this month" (highest priority)
# CUSTOMER scope: "Acme Corp is on the Enterprise tier" (high priority)
# CLIENT scope:  "Enterprise tier: 10,000 requests per minute" (medium priority)
In this example, the agent can combine all three scopes to give a complete answer: “Your Enterprise plan allows 10,000 requests per minute. I notice you have hit rate limits twice this month — would you like to review your usage patterns?”

​
TTL and caching

Organizational context is cached with a 30-minute TTL (time to live). This caching exists because organizational knowledge changes infrequently — product documentation is updated periodically, not on every request. The 30-minute TTL provides a balance between freshness and retrieval performance.
AspectDetail
Cache TTL30 minutes
Cache scopeLocal to the SDK client
Cache invalidationAutomatic on TTL expiry
Why cacheOrganizational context is read-heavy, write-infrequent
For most use cases, the 30-minute TTL is sufficient — new ingestions become visible within 30 minutes of processing completion as cached entries expire.

​
How organizational context merges with other scopes

During retrieval, organizational context is merged with customer-scoped and user-scoped memories following the scope chain priority rules. The merge process handles conflicts and redundancy:
ScenarioResolution
Same fact at multiple scopesNarrower scope wins (user > customer > client)
Complementary factsAll are included, ranked by relevance
Contradicting factsNarrower scope takes priority; broader scope may be included with lower rank
Budget exceededNarrower-scope memories are preserved first; organizational context is trimmed if necessary
This means that organizational context serves as a knowledge baseline that can be overridden by more specific customer or user context. For example:
  • Client scope: “Default support hours are 9am-5pm EST”
  • Customer scope: “Acme Corp has 24/7 premium support”
When Alice at Acme Corp asks about support hours, the customer-scoped memory takes priority, and the agent correctly responds with “24/7 premium support.”

​
Example: loading product docs at startup

A common pattern is to load your product documentation into organizational context when your application starts, and then update it whenever documentation changes: 
from maximem_synap import MaximemSynapSDK, CreateMemoryRequest
import glob

sdk = MaximemSynapSDK(api_key="your_api_key")

async def load_product_docs():
    """Load all product documentation into organizational context."""
    doc_files = glob.glob("docs/**/*.md", recursive=True)

    documents = []
    for filepath in doc_files:
        with open(filepath, "r") as f:
            documents.append(CreateMemoryRequest(
                document=f.read(),
                document_type="document",
            ))

    # Batch ingest at CLIENT scope
    result = await sdk.memories.batch_create(documents=documents)
    print(f"Submitted {result.total} documents: {result.succeeded} succeeded, {result.failed} failed")

async def handle_user_question(user_id: str, customer_id: str, question: str):
    """Handle a user question, drawing on organizational + personal context."""
    context = await sdk.user.context.fetch(
        user_id=user_id,
        customer_id=customer_id,
        search_query=[question]
    )

    # Build prompt with retrieved context
    prompt = f"""You are a helpful support agent.

Context from memory:
- Facts: {context.facts}
- Preferences: {context.preferences}

User question: {question}
"""
    # Pass prompt to your LLM...

​
Next steps

Customer Context

Learn about customer-scoped knowledge shared within an organization.

Memory Scopes

Understand the full scope chain and priority resolution rules.

SDK: Context

SDK reference for context retrieval.

Memory Architecture

Configure how organizational context is stored, extracted, and retrieved.