docker-neural-memory
构建使用Titans/TTT架构在测试时学习的容器化神经记忆。用于实现可学习记忆模块、测试时训练系统或MCP连接的记忆服务。触发于“神经记忆”、“测试时训练”、“Titans记忆”、“可学习记忆”、“会学习的记忆”、“TTT层”或构建基于Docker的AI记忆基础设施。
name: docker-neural-memory description: Build containerized neural memory that learns at test time using Titans/TTT architecture. Use when implementing learnable memory modules, test-time training systems, or MCP-connected memory services. Triggers on "neural memory", "test-time training", "Titans memory", "learnable memory", "memory that learns", "TTT layer", or building Docker-based AI memory infrastructure.
Docker Neural Memory
Build containerized neural memory that learns during inference using Google's Titans architecture and Stanford's TTT layers.
Core Concept
Traditional Memory (RAG/Vector DB): Neural Memory (Titans/TTT):
──────────────────────────────────── ────────────────────────────────────
Input → Embed → Store → Retrieve Input → Learn → Update Weights → Infer
(static) (dynamic)
store(content) → save embedding observe(context) → weights update
query(prompt) → similarity search infer(prompt) → generate from model
Key insight: The memory IS a neural network. Updates happen via gradient descent during inference.
Architecture Overview
┌─────────────────────────────────────────────────────────────┐
│ Docker Neural Memory │
├─────────────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Memory │ │ Learning │ │ State │ │
│ │ Module │ │ Engine │ │ Manager │ │
│ │ (Titans) │ │ (TTT) │ │ (Volumes) │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │ │
│ ┌───────▼───────┐ │
│ │ MCP Server │ │
│ └───────────────┘ │
└─────────────────────────────────────────────────────────────┘
Implementation Workflow
Phase 1: Core Memory Module
Implement the Titans neural memory. See references/titans-architecture.md for detailed implementation.
# Core structure (simplified)
class NeuralMemory(nn.Module):
def __init__(self, dim: int):
self.memory_net = nn.Sequential(
nn.Linear(dim, dim * 4),
nn.GELU(),
nn.Linear(dim * 4, dim)
)
self.lr = nn.Parameter(torch.tensor(0.01))
def forward(self, x: Tensor, learn: bool = True) -> Tensor:
output = self.memory_net(x)
if learn:
loss = self._compute_surprise(x, output)
# Update weights during inference (the key innovation)
self._update_weights(loss)
return output
Validation: Verify surprise decreases on repeated patterns.
Phase 2: TTT Layer Integration
Add Test-Time Training layer for expressive hidden states. See references/titans-architecture.md.
Two variants:
- TTT-Linear: Hidden state is linear model (faster)
- TTT-MLP: Hidden state is 2-layer MLP (more expressive)
Phase 3: Docker Containerization
Package as Docker image with persistent learned state:
FROM python:3.11-slim
RUN pip install torch transformers mcp-server
COPY src/ /app/
VOLUME ["/app/weights", "/app/checkpoints"]
ENV MEMORY_DIM=512
ENV TTT_VARIANT=mlp
ENV LEARNING_RATE=0.01
EXPOSE 8765
CMD ["python", "-m", "mcp_server"]
See references/docker-patterns.md for compose examples and multi-memory setups.
Phase 4: MCP Interface
Implement MCP server with learning-focused tools. See references/mcp-interface.md.
Core tools (different from traditional memory):
| Tool | Purpose | Unlike Traditional |
|---|---|---|
observe(context) |
Learn from input | store() just saves |
infer(prompt) |
Generate from learned model | query() just retrieves |
surprise(input) |
Measure novelty | No equivalent |
consolidate() |
Compress patterns | No equivalent |
checkpoint(tag) |
Save learned state | Database backup |
restore(tag) |
Load previous state | Database restore |
fork(src, new) |
Branch memory | No equivalent |
File Structure
docker-neural-memory/
├── src/
│ ├── memory/
│ │ ├── __init__.py
│ │ ├── neural_memory.py # Titans memory module
│ │ ├── ttt_layer.py # TTT-Linear and TTT-MLP
│ │ └── consolidation.py # Pattern compression
│ ├── mcp_server/
│ │ ├── __init__.py
│ │ ├── server.py # MCP server implementation
│ │ └── tools.py # Tool definitions
│ └── state/
│ ├── __init__.py
│ ├── checkpoint.py # Save/restore weights
│ └── versioning.py # Fork/branch logic
├── Dockerfile
├── docker-compose.yml
├── pyproject.toml
└── tests/
├── test_learning.py # Verify weights update
├── test_persistence.py # Verify state survives restart
└── test_mcp.py # MCP tool tests
Key Implementation Details
Surprise Calculation
def compute_surprise(self, x: Tensor, pred: Tensor) -> Tensor:
"""
Measure how surprising input is given current memory.
High surprise = worth learning. Low surprise = already known.
"""
return F.mse_loss(pred[:, :-1], x[:, 1:])
Weight Update During Inference
def _update_weights(self, loss: Tensor):
"""The key innovation: gradient descent during forward pass."""
grads = torch.autograd.grad(loss, self.memory_net.parameters())
with torch.no_grad():
for param, grad in zip(self.memory_net.parameters(), grads):
param -= self.lr * grad
Catastrophic Forgetting Mitigation
Use Elastic Weight Consolidation (EWC) to protect important weights:
def ewc_loss(self, current_loss: Tensor) -> Tensor:
"""Penalize changes to weights important for past patterns."""
ewc_penalty = 0
for name, param in self.memory_net.named_parameters():
ewc_penalty += (self.fisher[name] * (param - self.optimal[name])**2).sum()
return current_loss + self.ewc_lambda * ewc_penalty
Testing Checklist
Learning verification
# Surprise should decrease on repeated patterns s1 = memory.observe("Python uses indentation") s2 = memory.observe("Python uses indentation") assert s2.surprise < s1.surprisePersistence verification
# Start, learn, stop, restart, verify knowledge retained docker run -v weights:/app/weights neuralmemory/base # ... observe some patterns ... docker stop container docker start container # ... verify low surprise on same patterns ...Generalization verification
# Should generalize beyond exact matches memory.observe("Use with statement for files in Python") memory.observe("Use context managers for resources") result = memory.infer("How to handle database connections?") # Should suggest context managers (generalized pattern)
References
references/titans-architecture.md- Detailed Titans/TTT implementationreferences/mcp-interface.md- Complete MCP tool specificationsreferences/docker-patterns.md- Docker compose and deployment patterns
Key Papers
- Titans (Dec 2024): https://arxiv.org/abs/2501.00663
- TTT Layers (Jul 2024): https://arxiv.org/abs/2407.04620
- ATLAS (May 2025): https://arxiv.org/abs/2505.23735
- TPTT (Jun 2025): https://arxiv.org/abs/2506.17671 - PyPI:
tptt
Useful Starting Points
- TPTT library:
pip install tptt- Framework for Titans conversion - MCP SDK:
pip install mcp- Model Context Protocol server - OpenMemory (reference): https://github.com/CaviraOSS/OpenMemory