FAQ

Trix is a memory layer for AI applications. It provides persistent, searchable storage for any information your AI needs to remember — conversations, user preferences, documents, and more. Trix handles the complexity of embeddings, semantic search, and knowledge graphs so you can focus on building your product.

While vector databases store embeddings and enable similarity search, Trix is a complete memory solution built specifically for AI applications. Key differences:

• Automatic embedding generation — no need to manage embedding models
• Fact and entity extraction — structured knowledge from unstructured text
• Knowledge graphs — relationships between memories and entities
• Priority and decay — intelligent memory management over time
• Session isolation — built-in multi-tenancy for user data

Trix works with any LLM. It's model-agnostic — you retrieve memories via the API or SDK and inject them into your prompts. We have guides for common models:

• OpenAI (GPT-4 class)
• Anthropic (Claude family)
• Google (Gemini)
• Mistral
• xAI (Grok)
• Open-source models (Llama, etc.)

For Claude Desktop, Cursor, and Windsurf, you can also use our MCP Server for direct integration.

Yes! The free tier includes:

• 1,000 memories
• 5,000 search queries per month
• 3 spaces
• 100 credits per month
• 30 minutes audio transcription
• Community support

This is enough for personal projects and prototypes. Upgrade to Pro or Max for higher limits.

Create an account and generate an API key using the CLI:

# Create an account
trix auth register

# Generate an API key
trix keys create --name "my-app"

# The key is displayed once — save it securely!

See Authentication for more details.

Choose based on your tech stack:

• Python — pip install trixdb for Python 3.8+
• TypeScript/JavaScript — npm install @trixdb/client for Node.js or browser
• Other languages — Use the REST API directly

Create a test API key with the gdb_test_ prefix:

trix keys create --name "development" --type test

Test keys use isolated storage that's separate from production. You can clear test data anytime without affecting production memories.

Memory size limits depend on your plan. Free tier has smaller limits; Pro, Max, and Enterprise tiers support larger memories.

For larger content, consider chunking into multiple related memories and linking them with relationships.

Use sessions to isolate memories per user:

// Use spaces to isolate user data
const trix = new Trix({ apiKey: process.env.TRIX_API_KEY });

// Each user's memories are isolated by space
await trix.memories.create({ content: 'Prefers dark mode', spaceId: 'user_123' });
await trix.memories.create({ content: 'Prefers light mode', spaceId: 'user_456' });

// Queries only return the specified space's memories
const results = await trix.memories.list({ q: 'preferences', spaceId: 'user_123' });

For multi-tenant applications with separate configurations, use Spaces in addition to sessions.

Yes, as of v1.4.0! You can attach files up to 10MB to memories:

• Images (PNG, JPEG, GIF, WebP)
• Documents (PDF)
• The attachment is stored alongside the text content

For document search, we recommend extracting text from PDFs before storing as that enables better semantic search.

Delete all memories for a session using the CLI or API:

# List memories for a user
trix memories list --session user_123

# Delete all memories for the user
trix memories list --session user_123 --id-only | trix forget - --force

Semantic search finds memories based on meaning using vector similarity. "How do I deploy?" matches "deployment instructions" even without exact word overlap.

Hybrid search combines semantic search with keyword matching (BM25). It's the default in Trix because it handles both conceptual queries and exact term searches well.

// Hybrid (default) — best for most cases
const results = await trix.memories.list({ q: 'user preferences' });

// Semantic only — when meaning matters more than exact words
const results = await trix.memories.list({ q: 'user preferences', mode: 'semantic' });

// Fulltext only — when you need exact keyword matching
const results = await trix.memories.list({ q: 'API_KEY_123', mode: 'keyword' });

Tips for better search results:

• Be specific in queries — "user's dark mode preference" beats "settings"
• Add context to memories — include who, what, when, why
• Use tags — filter by tags to narrow results
• Reinforce important memories — trix reinforce ID
• Adjust min_score — filter out low-relevance matches

By default, recall() returns up to 10 memories. You can adjust this:

// Return more results
const results = await trix.memories.list({ q: 'query', limit: 25 });

// Filter by minimum quality score
const results = await trix.memories.list({
  q: 'query',
  limit: 10,
  minQuality: 0.7
});

Install the Trix MCP server to give Claude access to your memories:

# Run the MCP server (HTTP, port 3000 by default)
npx @trix/mcp

# Configure in Claude Desktop settings
# Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
  "mcpServers": {
    "trix": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer gdb_your_api_key"
      }
    }
  }
}

See MCP Server for full instructions.

Yes — Trix is framework-agnostic. A dedicated TrixRetriever class for LangChain/LlamaIndex is planned but not yet published; until then, wire Trix search into a custom retriever using the SDK directly:

from langchain.schema import BaseRetriever, Document
from trix import Trix

client = Trix(api_key="...")

class TrixLangChainRetriever(BaseRetriever):
    def _get_relevant_documents(self, query, *, run_manager):
        results = client.memories.list(q=query, limit=10)
        return [Document(page_content=m.content, metadata=m.metadata or {})
                for m in results.data]

# Use in your chain
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI
chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(),
    retriever=TrixLangChainRetriever(),
)

Configure webhooks to receive events:

# Register a webhook
curl -X POST https://api.trixdb.com/v1/webhooks \
  -H "Authorization: Bearer $TRIX_API_KEY" \
  -d '{
    "url": "https://your-app.com/webhooks/trix",
    "events": ["memory.created", "memory.updated", "memory.deleted"]
  }'

See Webhooks for event payloads and verification.

Usage is measured in several dimensions:

• Memories — total number stored (not API calls)
• Search queries — each recall() or search API call
• Embeddings — generated when creating/updating memories

Read operations like memories.get() and memories.list() don't count toward search limits.

When you hit a limit:

• Rate limits — 429 error, retry after the specified delay
• Monthly quotas — 403 error, upgrade or wait for next billing cycle
• Storage limits — Cannot create new memories until you delete some

We send email warnings at 80% and 90% of your quota.

Yes, you can downgrade at any time. The change takes effect at the start of your next billing cycle. If your current usage exceeds the lower plan's limits, you'll need to reduce usage before the downgrade takes effect.

Yes, we use encryption at multiple levels:

• In transit — All API traffic uses TLS 1.3
• At rest — AES-256 encryption for stored data
• API keys — Hashed using bcrypt, never stored in plain text

By default, data is stored in our US data centers. Enterprise customers can request:

• EU data residency
• Dedicated infrastructure
• Custom data retention policies

Contact [email protected] for data residency options.

No. Your data is never used to train models. We use third-party embedding models (OpenAI, Cohere) to generate vectors, but these are API calls that don't retain your data. Enterprise customers can also bring their own embedding models.

Please email [email protected] with details. We respond within 24 hours and offer a bug bounty program for qualifying reports. Do not disclose vulnerabilities publicly until we've had a chance to patch them.