Docs cleanup: working memory, extraction

Author: abrookins

docs/advanced-topics-index.md

@@ -0,0 +1,48 @@
+# Advanced Topics
+
+Optimize memory search, tune ranking algorithms, and configure advanced vector store features.
+
+<div class="grid cards" markdown>
+
+-   🔍 **Query Optimization**
+
+    ---
+
+    Improve search accuracy with query expansion and rewriting
+
+    [Query Optimization →](query-optimization.md)
+
+-   ⏱️ **Recency Boost**
+
+    ---
+
+    Time-aware memory ranking for more relevant results
+
+    [Recency Boost →](recency-boost.md)
+
+-   🗄️ **Advanced Vector Store Config**
+
+    ---
+
+    Fine-tune vector indexing, distance metrics, and performance
+
+    [Vector Store Config →](vector-store-advanced.md)
+
+-   🎯 **Contextual Grounding**
+
+    ---
+
+    Resolve pronouns and references in extracted memories
+
+    [Contextual Grounding →](contextual-grounding.md)
+
+</div>
+
+## When to Use These Features
+
+| Feature | Use When |
+|---------|----------|
+| Query Optimization | Search results aren't matching user intent well |
+| Recency Boost | Recent memories should rank higher than older ones |
+| Advanced Vector Config | You need to tune performance or use custom distance metrics |
+| Contextual Grounding | Extracted memories contain unresolved pronouns like "he" or "it" |

docs/api-reference-index.md

@@ -0,0 +1,43 @@
+# API Reference
+
+Complete reference documentation for all Redis Agent Memory Server interfaces.
+
+<div class="grid cards" markdown>
+
+-   🌐 **REST API**
+
+    ---
+
+    HTTP endpoints for memory operations with complete examples
+
+    [REST API Reference →](api.md)
+
+-   🤖 **MCP Server**
+
+    ---
+
+    Model Context Protocol tools for AI agents (Claude Desktop, etc.)
+
+    [MCP Reference →](mcp.md)
+
+-   💻 **CLI Reference**
+
+    ---
+
+    Command-line interface for server management
+
+    [CLI Reference →](cli.md)
+
+</div>
+
+## Interface Comparison
+
+| Interface | Best For | Authentication |
+|-----------|----------|----------------|
+| REST API | Applications, backends, custom integrations | OAuth2/JWT or token |
+| MCP Server | Claude Desktop, MCP-compatible AI agents | Environment config |
+| CLI | Server administration, development | Local access |
+
+## Interactive API Docs
+
+When running the server locally, visit `http://localhost:8000/docs` for interactive Swagger documentation where you can try endpoints directly.

docs/developer-guide-index.md

@@ -0,0 +1,59 @@
+# Developer Guide
+
+Learn how to integrate memory into your AI applications. This guide covers integration patterns, memory types, extraction strategies, and production considerations.
+
+## Core Concepts
+
+<div class="grid cards" markdown>
+
+-   🔄 **Memory Integration Patterns**
+
+    ---
+
+    Three patterns for using memory: LLM-driven, code-driven, and background extraction
+
+    [Integration Patterns →](memory-integration-patterns.md)
+
+-   📝 **Working Memory**
+
+    ---
+
+    Session-scoped storage for active conversation state
+
+    [Working Memory →](working-memory.md)
+
+-   🧠 **Long-term Memory**
+
+    ---
+
+    Persistent, cross-session storage for knowledge that should be retained
+
+    [Long-term Memory →](long-term-memory.md)
+
+-   🎯 **Memory Extraction Strategies**
+
+    ---
+
+    Configure how memories are extracted: discrete, summary, preferences, or custom
+
+    [Extraction Strategies →](memory-extraction-strategies.md)
+
+</div>
+
+## Additional Topics
+
+| Topic | Description |
+|-------|-------------|
+| [Memory Lifecycle](memory-lifecycle.md) | How memories are created, updated, and managed over time |
+| [Vector Store Backends](vector-store-backends.md) | Configure Redis, Pinecone, Chroma, or other backends |
+| [AWS Bedrock](aws-bedrock.md) | Using AWS Bedrock for embeddings and generation |
+| [Authentication](authentication.md) | OAuth2/JWT and token-based authentication |
+| [Security](security-custom-prompts.md) | Security considerations for custom prompts |
+
+## Where to Start
+
+**Building a chatbot?** Start with [Memory Integration Patterns](memory-integration-patterns.md) to understand your options.
+
+**Need to understand the data model?** Read [Working Memory](working-memory.md) and [Long-term Memory](long-term-memory.md).
+
+**Configuring extraction behavior?** See [Memory Extraction Strategies](memory-extraction-strategies.md).

docs/getting-started-index.md

@@ -0,0 +1,37 @@
+# Getting Started
+
+Get up and running with Redis Agent Memory Server. Whether you want a quick 5-minute setup or a comprehensive installation guide, start here.
+
+<div class="grid cards" markdown>
+
+-   🚀 **Quick Start**
+
+    ---
+
+    Get a working memory server in 5 minutes with the Python SDK
+
+    [Quick Start Guide →](quick-start.md)
+
+-   📦 **Installation**
+
+    ---
+
+    Complete installation options: CLI, Docker Compose, and production setup
+
+    [Installation Guide →](getting-started.md)
+
+-   💡 **Use Cases**
+
+    ---
+
+    Real-world examples across industries and applications
+
+    [Explore Use Cases →](use-cases.md)
+
+</div>
+
+## Recommended Path
+
+**New to memory systems?** Start with the [Quick Start Guide](quick-start.md) to understand the basics and see immediate results.
+
+**Ready for production?** Jump to the [Installation Guide](getting-started.md) for Docker Compose setup and worker configuration.

docs/memory-extraction-strategies.md

@@ -1,19 +1,17 @@
 # Memory Extraction Strategies
 
-The Redis Agent Memory Server supports configurable memory extraction strategies that determine how memories are extracted from conversations when they are promoted from working memory to long-term storage.
+This reference documents the configurable extraction strategies that determine how memories are extracted from conversations during [background extraction](memory-integration-patterns.md#pattern-3-background-extraction-automatic).
 
-## Overview
-
-Memory strategies allow you to customize the extraction behavior for different use cases:
+## Available Strategies
 
-- **Discrete Strategy**: Extract individual facts and preferences (default)
-- **Summary Strategy**: Create conversation summaries
-- **Preferences Strategy**: Focus on user preferences and characteristics
-- **Custom Strategy**: Use domain-specific extraction prompts
+| Strategy | Description | Best For |
+|----------|-------------|----------|
+| **Discrete** (default) | Extract individual facts and preferences | General chat, factual information |
+| **Summary** | Create conversation summaries | Meeting notes, long conversations |
+| **Preferences** | Focus on user preferences and characteristics | Personalization, user profiles |
+| **Custom** | Use domain-specific extraction prompts | Technical, legal, medical domains |
 
-Each strategy produces different types of memories optimized for specific applications.
-
-## Available Strategies
+## Strategy Reference
 
 ### 1. Discrete Memory Strategy (Default)
 
@@ -214,121 +212,11 @@ else:
 !!! info "Full Security Documentation"
     For comprehensive security guidance, attack examples, and production recommendations, see the [Security Guide](security-custom-prompts.md).
 
-## Strategy-Aware MCP Tools
-
-Each working memory session can generate MCP tools that understand its configured strategy:
-
-```python
-# Get strategy-specific tool description
-tool_description = working_memory.get_create_long_term_memory_tool_description()
-
-# Create strategy-aware MCP tool
-create_memories_tool = working_memory.create_long_term_memory_tool()
-```
-
-The generated tools include strategy-specific guidance in their descriptions, helping LLMs understand the expected extraction behavior.
-
-**Example Tool Descriptions:**
-
-=== "Discrete Strategy"
-    ```
-    Create long-term memories by extracting discrete semantic and episodic facts.
-    Focus on individual facts, user preferences, and specific events.
-    ```
-
-=== "Summary Strategy"
-    ```
-    Create long-term memories by summarizing conversation content.
-    Generate concise summaries capturing key discussion points.
-    ```
-
-=== "Custom Strategy"
-    ```
-    Create long-term memories using custom extraction focused on:
-    - Technology choices made
-    - Architecture decisions
-    - Implementation details
-    ```
-
-## Usage Examples
-
-### Basic Strategy Configuration
-
-```python
-from agent_memory_client import MemoryAPIClient
-from agent_memory_server.models import MemoryStrategyConfig
-
-client = MemoryAPIClient()
-
-# Configure strategy for technical discussions
-tech_strategy = MemoryStrategyConfig(
-    strategy="custom",
-    config={
-        "custom_prompt": """
-        Extract technical decisions from: {message}
-        Focus on technology choices, architecture, and implementation details.
-        Return JSON with memories array.
-        """
-    }
-)
-
-# Apply to working memory
-working_memory = await client.set_working_memory(
-    session_id="tech-session",
-    messages=[
-        {"role": "user", "content": "Let's use PostgreSQL for the database and Redis for caching"},
-        {"role": "assistant", "content": "Good choices! That architecture will scale well."}
-    ],
-    long_term_memory_strategy=tech_strategy
-)
-```
-
-### Strategy Selection by Use Case
-
-```python
-def get_strategy_for_domain(domain: str) -> MemoryStrategyConfig:
-    """Select appropriate strategy based on application domain."""
-
-    if domain == "customer_support":
-        return MemoryStrategyConfig(
-            strategy="preferences",
-            config={}
-        )
-
-    elif domain == "meeting_notes":
-        return MemoryStrategyConfig(
-            strategy="summary",
-            config={"max_summary_length": 800}
-        )
-
-    elif domain == "technical_consulting":
-        return MemoryStrategyConfig(
-            strategy="custom",
-            config={
-                "custom_prompt": """
-                Extract technical recommendations from: {message}
-                Focus on: technology stack, architecture patterns, best practices.
-                Format as JSON memories.
-                """
-            }
-        )
-
-    else:
-        # Default to discrete strategy
-        return MemoryStrategyConfig(
-            strategy="discrete",
-            config={}
-        )
-
-# Use domain-specific strategy
-strategy = get_strategy_for_domain("technical_consulting")
-```
-
-### REST API Integration
+## REST API Usage
 
 ```bash
 # Configure memory strategy via REST API
-curl -X POST "http://localhost:8000/v1/working-memory/" \
+curl -X PUT "http://localhost:8000/v1/working-memory/my-session" \
   -H "Content-Type: application/json" \
   -d '{
     "session_id": "api-session",
@@ -342,6 +230,8 @@ curl -X POST "http://localhost:8000/v1/working-memory/" \
   }'
 ```
 
+For more comprehensive integration examples, see [Memory Integration Patterns](memory-integration-patterns.md).
+
 ## Best Practices
 
 ### 1. Strategy Selection Guidelines