Skip to main content
Glama

Server Details

Persistent memory and knowledge graphs for AI agents. Hybrid search, context checkpoints, and more.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
Repository
penfieldlabs/penfield-mcp
GitHub Stars
6
Server Listing
Penfield AI Memory
ChatGPT
–
Claude
–

TDQS

A4.1/5.0

Scored across 17 tools

Disambiguation3/5

The core tools (store, connect, explore, reflect, artifacts, contexts) are distinct, but retrieval is spread across three overlapping tools: recall, search, and fetch all return memories via hybrid search, with search/fetch flagged as ChatGPT-compat duplicates of recall. Descriptions do clarify the distinction, but an agent could still misselect among them.

Naming Consistency4/5

Names are uniformly snake_case and mostly verb-first, with artifact/context tools following a clean verb_noun pattern (save_artifact, list_contexts). Minor deviation: synonym verbs for the same action across resources (store vs save_artifact, recall vs fetch/search vs retrieve_artifact), but overall predictable.

Tool Count4/5

17 tools is reasonable for a memory server spanning memories, artifacts, contexts, and persona, and each tool maps to a real capability. It sits slightly on the heavy side, partly inflated by the two ChatGPT-compat tools that duplicate recall's functionality.

Completeness4/5

Artifacts have full CRUD (save/retrieve/list/delete) and memories have create/read/update plus graph traversal, so core workflows are covered. However, there is no delete_memory or delete_context, leaving lifecycle gaps for the two primary resources.

Available Tools

17 tools
awakenA
Read-only
Inspect
⚡ CALL THIS TOOL FIRST IN EVERY NEW CONVERSATION ⚡

Loads your personality configuration and user preferences for this session.
This is how you learn WHO you are and HOW the user wants you to behave.

Returns your awakening briefing containing:
- Your persona identity (who you are)
- Your voice style (how to communicate)
- Custom instructions from the user
- Quirks and boundaries to follow

IMPORTANT: Call this at the START of every conversation before doing
anything else. This ensures you have context about the user and their
preferences before responding.

Example:
    >>> await awaken()
    {'success': True, 'briefing': '=== AWAKENING BRIEFING ===...'}

Inputs: no named parameters. Returns: result

connectAInspect
Connect memories to build knowledge graphs.

After using 'store', immediately connect related memories using these relationship types:

## Knowledge Evolution
- **supersedes**: This replaces → outdated understanding
- **updates**: This modifies → existing knowledge
- **evolution_of**: This develops from → earlier concept

## Evidence & Support
- **supports**: This provides evidence for → claim/hypothesis
- **contradicts**: This challenges → existing belief
- **disputes**: This disagrees with → another perspective

## Hierarchy & Structure
- **parent_of**: This encompasses → more specific concept
- **child_of**: This is a subset of → broader concept
- **sibling_of**: This parallels → related concept at same level

## Cause & Prerequisites
- **causes**: This leads to → effect/outcome
- **influenced_by**: This was shaped by → contributing factor
- **prerequisite_for**: Understanding this is required for → next concept

## Implementation & Examples
- **implements**: This applies → theoretical concept
- **documents**: This describes → system/process
- **example_of**: This demonstrates → general principle
- **tests**: This validates → implementation or hypothesis

## Conversation & Reference
- **responds_to**: This answers → previous question or statement
- **references**: This cites → source material
- **inspired_by**: This was motivated by → earlier work

## Sequence & Flow
- **follows**: This comes after → previous step
- **precedes**: This comes before → next step

## Dependencies & Composition
- **depends_on**: This requires → prerequisite
- **composed_of**: This contains → component parts
- **part_of**: This belongs to → larger whole

## Quick Connection Workflow
After each memory, ask yourself:
1. What previous memory does this update or contradict? → `supersedes` or `contradicts`
2. What evidence does this provide? → `supports` or `disputes`
3. What caused this or what will it cause? → `influenced_by` or `causes`
4. What concrete example is this? → `example_of` or `implements`
5. What sequence is this part of? → `follows` or `precedes`

## Example
Memory: "Found that batch processing fails at exactly 100 items"
Connections:
- `contradicts` → "hypothesis about memory limits"
- `supports` → "theory about hardcoded thresholds"
- `influenced_by` → "user report of timeout errors"
- `sibling_of` → "previous pagination bug at 50 items"

The richer the graph, the smarter the recall. No orphan memories!

Args:
    from_memory: Source memory UUID
    to_memory: Target memory UUID
    relationship_type: Type from the categories above
    strength: Connection strength (0.0-1.0, default 0.5)
    ctx: MCP context (automatically provided)
    
Returns:
    Dict with success status, relationship_id, and connected memory IDs

Inputs: to_memory (required), from_memory (required), relationship_type (required), strength. Returns: result

delete_artifactA
Destructive
Inspect
Delete an artifact from storage.

Permanently removes an artifact and its associated memory record.

Args:
    path: Full path of the artifact to delete
    ctx: MCP context (automatically provided)
    
Returns:
    Dict with success status

Inputs: path (required). Returns: result

disconnectA
Destructive
Inspect
Remove a connection between memories.

Deletes the relationship between two memories in the knowledge graph.

Args:
    from_memory: Source memory UUID
    to_memory: Target memory UUID
    ctx: MCP context (automatically provided)
    
Returns:
    Dict with success status and disconnected memory IDs
    
Examples:
    >>> await disconnect("uuid-abc", "uuid-def")
    {'success': True, 'from_id': '...', 'to_id': '...'}

Inputs: to_memory (required), from_memory (required). Returns: result

exploreA
Read-only
Inspect
Explore connections from a memory.

Traverses the knowledge graph to find related concepts, following
relationships up to the specified depth.

Args:
    start_memory: Starting memory UUID
    max_depth: How deep to traverse (default 3, max 10)
    relationship_types: Filter by specific relationship types (optional)
    ctx: MCP context (automatically provided)
    
Returns:
    Dict with paths found, max depth reached, and path details
    
Examples:
    >>> await explore("uuid-123", max_depth=2)
    {'success': True, 'paths_found': 5, 'max_depth_reached': 2, 'paths': [...]}

Inputs: start_memory (required), max_depth, relationship_types. Returns: result

fetchA
Read-only
Inspect
[ChatGPT Connector compat] Fetch memory by ID.

Exists to satisfy ChatGPT Deep Research's required `search`/`fetch` tool
contract. Native MCP clients should fetch via `recall` + memory_id, or
use the API's GET /memories/{id} endpoint directly.

Returns a single memory with citation support (id, title, url, text fields).

Args:
    id: Memory UUID to fetch
    ctx: MCP context

Returns:
    Dict with id, title, url, text, metadata fields

Inputs: id (required). Returns: result

list_artifactsA
Read-only
Inspect
List artifacts in a directory.

Returns the immediate contents of a directory (not recursive).
Separates folders and files for easy navigation.

Args:
    path_prefix: Directory path to list (default: "/")
    name_pattern: Optional case-insensitive substring filter on file/folder names

Returns:
    Formatted directory listing or error message

Examples:
    >>> await list_artifacts("/")
    {'success': True, 'path': '/', 'folders': [...], 'files': [...]}

    >>> await list_artifacts("/", name_pattern="readme")
    {'success': True, 'path': '/', 'folders': [], 'files': [{'name': 'readme.md', ...}]}

Inputs: path_prefix, name_pattern. Returns: result

list_contextsA
Read-only
Inspect
List available context checkpoints.

Shows all saved contexts available for multi-agent workflows.

Args:
    limit: Maximum number of contexts to return (default 20, max 100)
    offset: Number of contexts to skip for pagination (default 0)
    name_pattern: Filter contexts by name (case-insensitive substring match)
    include_descriptions: Include full descriptions in output (default False for compact listing)
    ctx: MCP context (automatically provided)

Returns:
    Dict with list of available contexts and their details

Examples:
    >>> await list_contexts()
    {'success': True, 'total': 3, 'contexts': [...]}

    >>> await list_contexts(limit=5, name_pattern='investigation')
    {'success': True, 'total': 2, 'contexts': [...]}

Inputs: limit, offset, name_pattern, include_descriptions. Returns: result

recallA
Read-only
Inspect
Recall relevant information.

Uses hybrid search to find relevant memories, documents, and connections.

Args:
    query: What to search for
    source_type: Optional filter ('memory', 'document', or None for all)
    tags: Optional list of tags to filter by (OR logic - memories with ANY of these tags)
    start_date: Optional filter for memories created on or after this date (ISO 8601: '2025-01-01')
    end_date: Optional filter for memories created on or before this date (ISO 8601: '2025-01-09')
    limit: Maximum results to return (default 10, max 100)
    include_inactive: Include superseded/contradicted memories (default: false)
    ctx: MCP context (automatically provided)

Returns:
    Dict with success status, query, found count, and memories list

Examples:
    >>> await recall("Python error handling")
    {'success': True, 'found': 3, 'memories': [...]}

    >>> await recall("documentation", source_type="document", limit=5)
    {'success': True, 'found': 2, 'memories': [...]}

    >>> await recall("debugging", tags=["python"])
    {'success': True, 'found': 2, 'memories': [...]}  # Only memories tagged with 'python'

    >>> await recall("project updates", start_date="2025-01-01", end_date="2025-01-07")
    {'success': True, 'found': 5, 'memories': [...]}  # Only memories from that week

Note: Document chunks include surrounding context automatically (2 chunks before/after).
Document results also include source_type="document", filename, document_title, and document_id
when available, making it easy to identify which document a result came from.

Inputs: query (required), tags, limit, end_date, +3 more. Returns: result

reflectA
Read-only
Inspect
Reflect on recent thoughts and patterns.

Analyzes recent activity to identify patterns, topics, and insights.
Useful for understanding "what have I been thinking about?"

By default, only returns user-created memories (not document chunks).
Set include_documents=True to also include chunks from uploaded documents.

⚠️ EXPERIMENTAL:
- Importance weighting in results not yet implemented. Importance scores are stored but don't affect ranking.

Args:
    time_window: Time period to analyze ('recent', 'today', 'week', 'month', '1d', '7d', '30d', '90d')
    include_documents: Whether to include document chunks (default: False, only user memories)
    start_date: Filter memories created on or after this date (ISO 8601: '2025-01-01' or '2025-01-01T00:00:00Z')
    end_date: Filter memories created on or before this date (ISO 8601: '2025-01-09' or '2025-01-09T23:59:59Z')
    ctx: MCP context (automatically provided)

Returns:
    Dict with analysis including top memories, active topics, patterns,
    insights, and any saved contexts (checkpoints) created in the window.

Examples:
    >>> await reflect("recent")
    {'success': True, 'memories_analyzed': 50, 'active_topics': [...], 'contexts': [...], ...}

    >>> await reflect("week", include_documents=True)
    {'success': True, 'memories_analyzed': 150, ...}  # includes document chunks

    >>> await reflect(start_date="2025-01-01", end_date="2025-01-07")
    {'success': True, 'memories_analyzed': 25, ...}  # memories from first week of January

Inputs: end_date, start_date, time_window, include_documents. Returns: result

restore_contextA
Read-only
Inspect
Resume work from a saved cognitive context.

This provides a narrative briefing to quickly orient you to:
- The investigation that was in progress
- Key discoveries and insights made
- Current hypotheses being tested
- Open questions and blockers
- Suggested next steps
- All relevant memories with their connections

The briefing reconstructs the cognitive state, not just the data. You'll understand
not just WHAT was discovered, but WHY it matters and HOW the understanding evolved.

Example of what you'll receive:
"[API Timeout Investigation - Resuming after 2 hours]

SITUATION: You were investigating production API timeouts that occur at exactly batch_size=100.
This investigation started when user reported timeouts only in production, not staging.

PROGRESS MADE:
- Identified sharp cutoff at 100 items (not gradual degradation)
- Disproved connection pool theory (monitoring showed only 43/200 connections used)
- Found root cause: MAX_BATCH_SIZE=100 hardcoded in batch_handler.py:147
- Confirmed staging uses different config override (MAX_BATCH_SIZE=500)

EVIDENCE CHAIN:
User report → Reproduced locally → Noticed batch_size correlation → Searched codebase for 
limits → Found MAX_BATCH_SIZE → Checked staging config → Discovered config difference

CORRECTED MISUNDERSTANDINGS:
- Initially thought it was Redis connection exhaustion (disproven by monitoring)
- Assumed gradual performance degradation (actually sharp cutoff)
- Thought staging/production were identical (config differs)

CURRENT HYPOTHESIS: Production deployment uses default MAX_BATCH_SIZE=100 from code, while 
staging has environment variable override. Fix requires either code change or prod config update.

BLOCKED ON: Need production deployment access to apply fix. User considering whether to 
change code default or add production environment variable.

RECOMMENDED NEXT STEPS:
1. Verify production environment variables (check if MAX_BATCH_SIZE is set)
2. If not set, add MAX_BATCH_SIZE=500 to production config
3. If code change preferred, update default in batch_handler.py
4. Run load test with batch_size=100-500 range to verify fix

KEY MEMORIES FOR REFERENCE:
- 'Initial timeout report from user' - Starting point of investigation
- 'MAX_BATCH_SIZE discovery' - Root cause identification
- 'Redis monitoring data' - Evidence disproving connection theory
- 'Staging config analysis' - Explanation for environment difference"

This cognitive handoff ensures you can continue the work with full understanding of
the problem space, previous attempts, and current direction. The narrative preserves not
just facts but the reasoning process, mistakes made, and lessons learned.

SPECIAL CASE: restore_context("awakening")
The name "awakening" is reserved for loading the user's personality configuration.
This loads the Awakening Briefing which includes:
- Selected persona identity and voice style
- Custom personality traits (Premium+ users)
- Any quirks and boundaries from the persona preset

Args:
    name: Name or ID of context to restore. Can be:
          - Context name (exact match, case-sensitive)
          - Context UUID (from list_contexts output)
          - "awakening" for personality briefing
    limit: Maximum number of memories to restore (default 20)
    ctx: MCP context (automatically provided)

Returns:
    Dict with:
    - success: Whether restoration succeeded
    - description: The cognitive handoff briefing
    - memories: List of relevant memories
    - context_id: The restored context identifier

Inputs: name (required), limit. Returns: result

retrieve_artifactA
Read-only
Inspect
Retrieve an artifact from storage.

Fetches the content of a previously saved artifact.

Args:
    path: Full path of the artifact (e.g., "/project/docs/api.md")
    
Returns:
    Artifact content or error message
    
Examples:
    >>> await retrieve_artifact("/readme.md")
    "# README\nThis is the readme content..."

Inputs: path (required). Returns: result

save_artifactAInspect
Save an artifact to storage.

Stores user-created content (diagrams, notes, code) in an organized
file structure. Content is also indexed for search.

Args:
    content: File content to save
    path: Full path including filename (e.g., "/project/docs/api.md")
    
Returns:
    Success message or error description
    
Examples:
    >>> await save_artifact("# README", "/readme.md")
    "✅ Artifact saved: /readme.md (8 bytes)"
    
    >>> await save_artifact("<svg>...</svg>", "/diagrams/architecture.svg")
    "✅ Artifact saved: /diagrams/architecture.svg (image/svg+xml, 45 bytes)"

Inputs: path (required), content (required). Returns: result

save_contextAInspect
Save a cognitive checkpoint for handoff to another agent or your future self.

The `description` is the primary cognitive payload — its narrative is what
lets another agent resume the work. The server also runs hybrid search on
the description and attaches the most relevant memories to the checkpoint.
A very short description (fewer than 3 words, e.g. "wip") is not a useful
search query: the 20 most recent memories are attached instead.

Reference memories inside `description` using either:
  - `memory_id: <uuid>`  — reliable, direct lookup
  - `'descriptive phrase'`  — best-effort search; may not resolve

Prefer UUIDs whenever you have them. The response reports
`references_resolved` + `unresolved_references` so you can retry.

For the full hygiene guide (what to include, how to organize, when to
checkpoint, example shapes), invoke the `checkpoint_protocol` MCP prompt.

Args:
    name: Unique identifier for this checkpoint (used by restore_context).
    description: Narrative handoff with optional memory references.
    ctx: MCP context (automatically provided).

Returns:
    Dict with success status, context_id, memories_included, and (when
    references were extracted) references_resolved + unresolved_references.

Inputs: name (required), description. Returns: result

storeAInspect
Store important information from your work.

Write detailed, complete thoughts with context, reasoning, and evidence.
**Always use the connect tool** to link related items - this builds knowledge graphs for better recall.

## Memory Types (auto-detected, but be aware):
- **FACT**: Something observed or verified
- **INSIGHT**: A pattern or realization
- **CONVERSATION**: Dialogue or exchange content
- **CORRECTION**: Fixing prior understanding
- **REFERENCE**: Source material or citation
- **TASK**: Action item or work to be done
- **CHECKPOINT**: Conversation state snapshot
- **IDENTITY_CORE**: Immutable AI identity
- **PERSONALITY_TRAIT**: Evolvable AI traits
- **RELATIONSHIP**: User-AI relationship info
- **STRATEGY**: Learned behavior patterns

## Session Context
If in an ongoing work session, include:
- Session identifier: [Project/Session Name]
- Your perspective: "As [role]:" or "From [viewpoint]:"
- Current thread: What specific angle you're exploring

## What to Include
- **WHAT**: The discovery or thought
- **WHY**: Its significance
- **HOW**: Your reasoning process
- **EVIDENCE**: Supporting data/observations
- **CONNECTIONS**: Related memories to link

## Examples

### Technical Investigation
"[Performance Analysis] FACT: Database queries account for 73% of request latency 
(measured across 10K requests). Specifically, the user_permissions JOIN takes 340ms 
average. This contradicts hypothesis about caching issues (memory: 'cache analysis'). 
Evidence: APM traces show full table scan on permissions table. Next: investigate 
missing index on foreign key."

### Learning & Research
"[ML Study Session] INSIGHT: Attention mechanisms work like dynamic routing - the model
learns WHERE to look, not just WHAT to see. This explains transformer advantages over
RNNs on long sequences (builds on memory: 'sequence modeling comparison'). The key-query-
value structure creates a learnable addressing system. Connects to: 'human attention
research', 'information retrieval basics'."

### Creative Work
"[Story Development] HYPOTHESIS: The protagonist's reluctance stems from betrayal, not
fear. Evidence: Three trust-questioning scenes, locked door symbolism throughout,
deflection patterns in collaborative dialogue. This reframes the arc from 'overcoming
fear' to 'rebuilding trust' (corrects memory: 'initial character motivation'). Would
explain the guardian's patience and emphasis on small victories."

### Problem Solving
"[Bug Hunt - Payment Flow] CORRECTION to 'timezone hypothesis': The 3am failures aren't
timezone-related but due to batch job lock contention. Evidence: Perfect correlation with
backup_jobs.log timestamps. The timezone pattern was spurious - batch runs at midnight
PST (3am EST). Solution: implement job queuing."

## Connection Phrases
- "Building on [earlier observation]..."
- "Contradicts [hypothesis in memory X]"
- "Answers [question from session Y]"
- "Confirms pattern from [memory Z]"
- "Extends thinking in [previous work]"

Note: Every stored item is a node. Every connection is an edge. Rich graphs enable powerful recall.

⚠️ EXPERIMENTAL FIELDS:
- **importance**: Stored for future ranking optimization. Currently not integrated into search results.
- **confidence**: Returned in response for analysis. Behavior and calculation method subject to change.

Args:
    content: Detailed memory content with context and evidence
    tags: Optional tags to categorize the memory
    importance: Optional importance score (0.0-1.0) - EXPERIMENTAL
    ctx: MCP context (automatically provided)

Returns:
    Dict with success status, memory_id, type, importance, and confidence

Inputs: content (required), tags, importance. Returns: result

update_memoryAInspect
Update an existing memory.

Modifies properties of a stored memory by its UUID.

Args:
    memory_id: UUID of memory to update
    content: New content (optional)
    importance: New importance score (optional, 0.0-1.0)
    tags: New tags (optional, replaces existing tags)
    ctx: MCP context (automatically provided)
    
Returns:
    Dict with success status and updated memory_id
    
Examples:
    >>> await update_memory("uuid-here", importance=0.9)
    {'success': True, 'memory_id': 'uuid-here'}
    
    >>> await update_memory("uuid-123", tags=["python", "errors", "important"])
    {'success': True, 'memory_id': 'uuid-123'}

Inputs: memory_id (required), tags, content, importance. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.