GitHub - thedotmack/claude-mem: Persistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More vs GitHub - rasbt/LLMs-from-scratch: Implement a ChatGPT-like LLM in PyTorch from scratch, step by step

## Overview

**Claude-Mem** is an open-source memory engine that captures, compresses, and injects context across AI agent sessions. It works with multiple agents like Claude Code, OpenClaw, Codex, Gemini, and more, using ChromaDB, SQLite, embeddings, and RAG to provide persistent memory.

**LLMs-from-scratch** is an educational GitHub repository by Sebastian Raschka that provides a comprehensive, step-by-step guide to implementing a ChatGPT-like large language model in PyTorch from scratch. It covers tokenization, attention mechanisms, pretraining, finetuning, and instruction tuning.

## Feature Comparison

| Feature | Claude-Mem | LLMs-from-scratch |

|---------|------------|-------------------|

| **Primary Function** | Persistent context memory for AI agents | Educational guide to build LLMs from scratch |

| **Target Users** | Developers using AI agents for multi-session tasks | ML engineers, researchers, students learning LLMs |

| **Technical Skill Required** | Moderate (self-hosting, API integration) | High (PyTorch, deep learning knowledge) |

| **Open Source** | Yes (GitHub) | Yes (MIT license) |

| **Self-Hosting** | Required | Optional (can run notebooks locally) |

| **Multi-Agent Support** | Yes (Claude Code, OpenClaw, Codex, Gemini, etc.) | No (focuses on building a single model) |

| **AI-Powered Compression** | Yes | No |

| **Pre-built Components** | Memory engine with RAG | Full model building pipeline |

| **Production Readiness** | Moderate (requires setup) | Low (educational, not production framework) |

| **GPU Requirement** | No (for memory engine itself) | Yes (for training larger models) |

## Use Cases

**Claude-Mem** is ideal for:

- Long-running development projects where agents need to remember code changes and decisions.

- Personal AI assistants that maintain user preferences across sessions.

- Multi-agent workflows where context sharing is critical.

**LLMs-from-scratch** is ideal for:

- Learning the internals of transformer-based LLMs.

- Experimenting with custom attention mechanisms or training techniques.

- Building small-scale LLMs for specialized domains without relying on external APIs.

## Pros and Cons

### Claude-Mem

**Pros:**

- Open-source and free to self-host

- Multi-agent support for popular AI agents

- AI-powered compression reduces storage overhead

- Relevant context injection improves session continuity

- Lightweight storage with ChromaDB and SQLite

**Cons:**

- Requires self-hosting and technical setup

- No official cloud-hosted version

- May incur infrastructure costs

- Dependent on underlying AI APIs for compression

- Limited documentation or community support

### LLMs-from-scratch

**Pros:**

- Comprehensive from-scratch implementation

- Well-documented with Jupyter notebooks

- Covers full pipeline: tokenization to instruction tuning

- Free and open-source (MIT license)

- Educational for understanding LLM internals

**Cons:**

- Requires PyTorch knowledge

- Training larger models needs GPU resources

- Not a production-ready framework

- Limited to small-scale models by default

- No built-in support for distributed training

## Which One Should You Choose?

- **Choose Claude-Mem** if you are a developer using AI agents (like Claude Code, Copilot, etc.) and need persistent memory across sessions. It’s a practical tool for enhancing agent workflows without building models from scratch.

- **Choose LLMs-from-scratch** if you want to deeply understand how LLMs work and are willing to invest time in learning PyTorch and model building. It’s an educational resource, not a drop-in solution.

Both tools are open-source and serve different purposes. Claude-Mem focuses on memory management for existing agents, while LLMs-from-scratch focuses on model construction education.