Rust自我学习记忆系统

Prerequisites

• Rust stable (2024 edition)
• SQLite (for local development)
• Optional: Turso CLI (for cloud database)

Quality Requirements

• All tests must pass
• No clippy warnings
• Test coverage targets per ADR-042:
• Phase 1: 70% (current focus - actual: 61.22%)
• Phase 2: 75%
• Phase 3: 80% (codecov.yml project target)
• Security audit must pass
• Performance benchmarks must not degrade >10%

Installation

```bash

Build the project

cargo build --release

Local Database Setup

```bash

Quick setup with the provided script

./scripts/setup-local-db.sh

Or manual setup

cp memory-cli/.env.example .env mkdir -p ./data ./backups ```

Quick Start

🔍 Pattern Search Example

use memory_core::{SelfLearningMemory, TaskContext, ComplexityLevel};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let memory = SelfLearningMemory::new();
    
    // Search for patterns using natural language
    let context = TaskContext {
        domain: "web-api".to_string(),
        language: Some("rust".to_string()),
        framework: None,
        complexity: ComplexityLevel::Moderate,
        tags: vec!["rest".to_string(), "async".to_string()],
    };
    
    let results = memory.search_patterns_semantic(
        "How to handle API rate limiting with retries",
        context,
        5  // limit
    ).await?;
    
    for result in results {
        println!("Pattern: {:?}", result.pattern);
        println!("Relevance: {:.2}", result.relevance_score);
        println!("Success Rate: {:.1}%", result.pattern.success_rate() * 100.0);
    }
    
    // Get task-specific recommendations
    let recommendations = memory.recommend_patterns_for_task(
        "Build async HTTP client with connection pooling",
        context,
        3
    ).await?;
    
    for rec in recommendations {
        println!("Recommended: {:?}", rec.pattern);
    }

    // Generate an actionable playbook
    let playbooks = memory.retrieve_playbooks(
        "Implement user authentication",
        "security",
        TaskType::CodeGeneration,
        context,
        1, // max playbooks
        5  // max steps
    ).await;

    if let Some(playbook) = playbooks.first() {
        println!("Playbook ID: {}", playbook.playbook_id);
        for step in &playbook.ordered_steps {
            println!("{}. {}", step.order, step.action);
        }
    }
    
    Ok(())
}

Documentation: See memory-core/PATTERN_SEARCH_FEATURE.md for complete API reference and examples.

Basic Usage

Setup Configuration

```bash

Run interactive configuration wizard

do-memory-cli config wizard

Follow the prompts to configure:

Validate configuration

do-memory-cli config validate

Check configuration status

do-memory-cli config check

Configuration Wizard provides interactive step-by-step setup with sensible defaults and validation.

#### CLI Interaction

Or run with custom config

cargo run --bin do-memory-mcp-server -- --config mcp-config-memory.json

#### Programmatic Usage

#[tokio::main] async fn main() -> anyhow::Result<()> { let memory = SelfLearningMemory::new(Default::default()).await?;

let context = TaskContext { language: "rust".to_string(), domain: "web".to_string(), tags: vec!["api".to_string()], };

let episode_id = memory.start_episode( "Build REST API endpoint".to_string(), context, TaskType::CodeGeneration, ).await;

Ok(()) } ```

Configuration

Environment Variables

```bash

Cache settings

MEMORY_MAX_EPISODES_CACHE=1000 MEMORY_CACHE_TTL_SECONDS=3600

CLI config

MEMORY_CLI_CONFIG=./do-memory-cli.toml

Sandbox settings

MCP_USE_WASM=true JAVY_PLUGIN=./memory-mcp/javy-plugin.wasm ```

TOML Configuration

[database]
turso_url = "libsql://your-db.turso.io"
turso_token = "your-auth-token"
redb_path = "memory.redb"

[storage]
max_episodes_cache = 1000
cache_ttl_seconds = 3600
pool_size = 10

[sandbox]
max_execution_time_ms = 5000
max_memory_mb = 128
max_cpu_percent = 50
allow_network = false
allow_filesystem = false

[cli]
default_format = "human"
progress_bars = true
batch_size = 100

- CLI (output format, progress bars, batch size)

Development Workflow

1. Fork the repository
2. Create a feature branch: git checkout -b feature-name
3. Make your changes
4. Run quality gates: ./scripts/quality-gates.sh
5. Submit a pull request