Memento Laravel Package

Technical Evaluation

Architecture Fit

• Neo4j Dependency: The package leverages Neo4j for graph-based memory storage, which is a strong fit for AI context retention but introduces external dependency complexity (database setup, licensing, and schema management). Laravel’s Eloquent ORM does not natively support Neo4j, requiring a custom integration layer (e.g., via neo4j-php-client).
• MCP (Model Context Protocol) Integration: MCP is a proprietary protocol for AI tooling. Laravel would need to expose an API endpoint (REST/gRPC) to bridge MCP-compatible clients (e.g., IDE plugins, LLMs) with Memento’s Neo4j backend. This adds cross-language complexity (Go ↔ PHP ↔ AI tool).
• Event-Driven Workflow: Memento’s design assumes real-time session persistence, which may conflict with Laravel’s traditional request-response cycle. A message queue (e.g., RabbitMQ, Redis Streams) could decouple AI tool interactions from Laravel’s core logic.
• Monolithic vs. Microservices: Memento’s all-in-one approach (Neo4j + MCP + Ollama) contrasts with Laravel’s application-centric philosophy. A microservice decomposition (e.g., separate Neo4j service, MCP API gateway) may be preferable for scalability.

Integration Feasibility

• PHP/Neo4j Compatibility: The neo4j-php-client library supports Cypher queries, but Memento’s custom graph schema (entities, relationships, context nodes) would require:
  • Schema migration scripts.
  • Laravel Service Providers to abstract Neo4j operations.
  • Model binding (e.g., MementoEntity, MementoRelationship) to map PHP objects to Neo4j nodes.
• MCP Protocol Handling: Laravel would need to:
  • Implement an MCP-compatible HTTP/WebSocket server (or proxy requests to a Go service).
  • Parse MCP payloads (JSON/Protobuf) and translate them into Neo4j transactions.
  • Handle authentication/authorization for AI tools (e.g., JWT, API keys).
• Ollama Integration: Memento uses Ollama for local LLM inference. Laravel could:
  • Delegate inference to Ollama via CLI calls (exec()) or a gRPC client.
  • Cache responses in Redis to reduce Ollama load.
• Session Persistence: Memento’s "remember everything" feature implies:
  • Database triggers or Laravel events to sync AI sessions with Neo4j.
  • Conflict resolution for concurrent writes (e.g., optimistic locking).

Technical Risk

Key Questions

1. Is Neo4j a Hard Requirement?
   • Could an alternative (e.g., PostgreSQL with pgvector, ArangoDB) reduce complexity?
2. How Will AI Tools Authenticate?
   • Will Laravel expose an OAuth2/MCP-specific auth layer, or delegate to Memento’s Go service?
3. What’s the Data Retention Policy?
   • Will Laravel enforce TTL (Time-to-Live) for graph nodes, or rely on Neo4j’s built-in features?
4. How Will Errors Be Handled?
   • Neo4j/Ollama failures should not crash Laravel. Will dead-letter queues or circuit breakers be used?
5. Is Real-Time Sync Needed?
   • If AI tools require sub-second persistence, Laravel’s ORM may not suffice—WebSockets or Server-Sent Events (SSE) could be needed.
6. How Will the Graph Scale?
   • Neo4j’s performance degrades with millions of nodes. Will Laravel implement sharding or graph partitioning?

Integration Approach

Stack Fit

• Laravel Core: Best suited for:
  • API layer (REST/gRPC endpoints for MCP clients).
  • Business logic (e.g., validating AI tool requests, enforcing policies).
  • Authentication (JWT/OAuth2 for AI tool integration).
• Neo4j: Handled via:
  • Laravel Service Container (bind neo4j-php-client).
  • Custom Eloquent-like models (e.g., MementoNode, MementoRelationship).
  • Repository pattern to abstract queries (e.g., GraphRepository).
• Ollama: Integrated via:
  • Artisan commands for model management.
  • HTTP/gRPC client for inference (e.g., ollama-php).
• MCP Protocol: Implemented as:
  • Laravel middleware to parse MCP payloads.
  • Event listeners to trigger Neo4j updates on AI tool interactions.

Migration Path

1. Phase 1: Proof of Concept (PoC)
   • Set up local Neo4j instance (Docker) and neo4j-php-client.
   • Implement basic CRUD for Memento entities (e.g., UserContext, DecisionNode).
   • Test with a mock MCP client (Postman/cURL).
2. Phase 2: API Gateway
   • Expose Laravel routes for MCP (e.g., /api/memento/context).
   • Use Laravel Sanctum/Passport for AI tool authentication.
3. Phase 3: Ollama Integration
   • Add Ollama CLI calls for inference (e.g., Artisan::call('ollama run mistral')).
   • Cache responses in Redis to avoid repeated calls.
4. Phase 4: Real-Time Sync
   • Implement Laravel Echo + Pusher for WebSocket-based updates.
   • Use Laravel Queues to offload Neo4j writes.
5. Phase 5: Scaling
   • Containerize Neo4j and Ollama in Docker/Kubernetes.
   • Add horizontal scaling for Laravel API (e.g., load balancer + multiple workers).

Compatibility

Sequencing

1. Database First
   • Set up Neo4j and define Memento’s graph schema (nodes: User, Session, Entity; relationships: HAS_CONTEXT, MAKES_DECISION).
2. API Layer
   • Build MCP-compatible endpoints before integrating AI tools.
3. Ollama Last
   • Defer Ollama integration until core persistence is stable (to avoid blocking on LLM performance).
4. Real-Time Features
   • Implement WebSockets only after REST API is validated (to reduce complexity).

Operational Impact