Product Launch

Introducing Records: Structured Data for AI Applications

Memories capture what your AI knows. Records capture what your AI manages. Define schemas, create and update records via API or automatically from conversations, query with filters, and search semantically.

Marius Ndini

Founder · Feb 16, 2026

Why Records?

Mnexium memories are great for capturing facts, preferences, and context from conversations. But many AI applications also need to manage structured business data — events on a calendar, deals in a pipeline, contacts in a CRM, tasks on a board, inventory items, support tickets.

Until now, you had two choices: build a separate database and API layer for your structured data, or try to shoehorn everything into unstructured memories. Neither is ideal.

Records give you a schema-driven, queryable, semantically-searchable data layer that lives right alongside your memories — and your AI can create and update records automatically from conversations, no extra code required.

How It Works

Records are built on three layers: Schemas define the shape of your data, the CRUD API lets you manage records programmatically, and the AI extraction pipeline lets your AI create and update records automatically from natural language.

1. Define a Schema

A schema tells Mnexium what fields a record type has, which are required, and how to display them. Schemas are defined per-project and can be updated at any time.

// JavaScript SDK
await mnx.records.defineSchema('events', {
  title:       { type: 'string', required: true, description: 'Event title' },
  date:        { type: 'string', required: true, description: 'Date (YYYY-MM-DD)' },
  time:        { type: 'string', description: 'Time (HH:MM)' },
  location:    { type: 'string', description: 'Location or address' },
  description: { type: 'string', description: 'Additional details' },
}, {
  displayName: 'Events',
  description: 'Calendar events and appointments',
});

Schemas support string, number, and reference types. Required fields are validated on insert.

# Python SDK
mnx.records.define_schema('events', {
    'title':       { 'type': 'string', 'required': True, 'description': 'Event title' },
    'date':        { 'type': 'string', 'required': True, 'description': 'Date (YYYY-MM-DD)' },
    'time':        { 'type': 'string', 'description': 'Time (HH:MM)' },
    'location':    { 'type': 'string', 'description': 'Location or address' },
    'description': { 'type': 'string', 'description': 'Additional details' },
}, display_name='Events', description='Calendar events and appointments')

Or via the REST API directly:

POST /api/v1/records/schemas
Authorization: Bearer mnx_...

{
  "type_name": "events",
  "display_name": "Events",
  "description": "Calendar events and appointments",
  "fields": {
    "title":       { "type": "string", "required": true },
    "date":        { "type": "string", "required": true },
    "time":        { "type": "string" },
    "location":    { "type": "string" },
    "description": { "type": "string" }
  }
}

2. Create and Update Records

Records are JSON objects validated against their schema. Each record gets a unique record_id, an auto-generated embedding for semantic search, and a human-readable summary. Updates are partial merges — send only the fields you want to change.

// Create a record
const event = await mnx.records.insert('events', {
  title: 'Doctor appointment',
  date: '2026-03-15',
  time: '10:00',
  location: 'Philadelphia',
});
// event.record_id → "rec_2fe18b47-..."

// Update it later (partial merge)
await mnx.records.update('events', event.record_id, {
  time: '14:00',
  location: 'New York',
});

# Python
event = mnx.records.insert('events', {
    'title': 'Doctor appointment',
    'date': '2026-03-15',
    'time': '10:00',
    'location': 'Philadelphia',
})

mnx.records.update('events', event.record_id, {
    'time': '14:00',
    'location': 'New York',
})

3. Query and Search

Records support two retrieval modes: structured queries with field-level filters, ordering, and pagination — and semantic search powered by embeddings. Use whichever fits your use case, or combine them.

// Structured query with filters
const upcoming = await mnx.records.query('events', {
  where: { location: 'Philadelphia' },
  orderBy: 'date',
  limit: 10,
});

// Semantic search — natural language
const results = await mnx.records.search('events', 'medical appointments next month');
// Returns records ranked by similarity score

Queries match on exact field values. Semantic search uses cosine similarity on embeddings.

4. AI-Powered Record Extraction

This is where Records get powerful. When you enable record extraction on your chat endpoint, Mnexium automatically analyzes each user message and determines if a record should be created or updated — without any extra code on your side.

Here's how it works under the hood:

Schema introspection — The pipeline loads all schemas for your project and dynamically generates LLM tool definitions (create_events, update_events, search_records)
Context injection — Any previously recalled records are included in the prompt so the LLM knows what already exists and can reference record_ids for updates
Tool-calling — The LLM decides whether to create, update, search, or do nothing. It can issue multiple tool calls in a single pass
Execution — Tool calls are executed with full validation, embedding regeneration, and activity logging

User says: "I have a doctor's appointment March 15th at 10am in Philly"
→ AI automatically calls create_events with:
   { title: "Doctor's appointment", date: "2026-03-15",
     time: "10:00", location: "Philadelphia" }

User says: "Actually, move that to 2pm"
→ AI automatically calls update_events with:
   { record_id: "rec_2fe18b47-...", time: "14:00" }

No code changes needed — just enable records on your chat endpoint

The extraction pipeline runs as a fire-and-forget background task — it never blocks the chat response.

5. Access Control

Records have built-in ownership and visibility controls. Every record has an owner_id, a visibility setting (public or private), and an optional collaborators list.

Write access (update, delete) is restricted to the owner and collaborators. Read access respects visibility — private records are only visible to the owner and collaborators. System actors (like the AI extraction pipeline) bypass ownership checks, so the AI can always manage records on behalf of users.

// Create a private record with collaborators
const deal = await mnx.records.insert('deals', {
  title: 'Acme Renewal',
  value: 500000,
  stage: 'negotiation',
}, {
  ownerId: 'user_alice',
  visibility: 'private',
  collaborators: ['user_bob', 'user_carol'],
});

// Only alice, bob, and carol can see or update this record
// Pass x-subject-id header to identify the caller

6. Cross-References with ref: Types

Schema fields can reference other record types using the ref: prefix. This creates typed foreign-key relationships between records that the system can follow automatically.

// Define a deals schema that references accounts
await mnx.records.defineSchema('deals', {
  title:      { type: 'string', required: true },
  value:      { type: 'number' },
  stage:      { type: 'string' },
  account_id: { type: 'ref:accounts', description: 'Linked account' },
});

// When a deal is loaded, related account records
// can be resolved automatically

Reference fields create navigable relationships between record types — like a lightweight relational model.

Under the Hood

Here's what happens under the hood when you create a record:

Validation — Data is validated against the schema. Required fields are checked, types are enforced.
Summary generation — A human-readable summary is built from the record's fields (e.g., [events] title=Doctor appointment, date=2026-03-15, location=Philadelphia).
Embedding — The summary is embedded for semantic search.
Storage — The record, embedding, and summary are persisted and indexed for fast queries.

On update, the data is merged at the field level and the summary and embedding are regenerated from the merged result. Deletes are soft, for the time being.

What Can You Build?

AI Calendar — Users mention events in conversation and they're automatically added to a structured calendar
CRM with AI — Deals, contacts, and accounts managed through natural language. "Close the Acme deal at $550k" just works.
Task Management — "Add a task to review the Q1 report by Friday" creates a structured task record with a due date
Inventory Tracking — Manage products, stock levels, and orders through conversational AI
Support Ticketing — Automatically create and update support tickets from customer conversations
Any domain model — Records are schema-driven. Define any structure and the AI adapts automatically.

API Reference

The full Records API is available via REST and both SDKs:

Endpoint	Method	Description
/records/schemas	POST	Define or update a schema
/records/schemas	GET	List all schemas
/records/schemas/:type	GET	Get a specific schema
/records/:type	POST	Create a record
/records/:type	GET	List records
/records/:type/:id	GET	Get a record by ID
/records/:type/:id	PUT	Update a record (partial merge)
/records/:type/:id	DELETE	Soft-delete a record
/records/:type/query	POST	Query with filters
/records/:type/search	POST	Semantic search

Records vs. Memories

A common question: when should you use Records vs. Memories?

	Memories	Records
Shape	Unstructured text	Schema-driven JSON
Best for	Facts, preferences, context	Business objects, entities
Query	Semantic search	Field filters + semantic search
Updates	Supersession (new replaces old)	Partial merge (field-level)
Access control	Per-subject	Owner + collaborators + visibility
AI extraction	Automatic from chat	Automatic from chat

Use memories for what your AI knows. Use records for what your AI manages. They work together — the unified extraction pipeline can create both from a single message.

Get Started

Records are available now in both SDKs and the REST API. Define a schema, create your first record, and enable AI extraction on your chat endpoint. Your AI will start managing structured data from conversations immediately.

npm install @mnexium/sdk    # JavaScript
pip install mnexium        # Python

Records are live

Give your AI a structured data layer. Define schemas, manage records via API, and let the AI extract and update records from natural conversation.

npm: @mnexium/sdk →PyPI: mnexium →Read the docs