daarion-admin/microdao-daarion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b79db5b2a4612feb658b0d2cb4d337b6bdcda7b0
microdao-daarion/PHASE2_READY.md

8.7 KiB
Raw Blame History

🎉 PHASE 2 AGENT INTEGRATION — READY TO START!

All specifications complete. Ready for implementation.

Date: 2025-11-24
Status: 📋 Ready
Estimated Time: 4-6 weeks

📚 What We Have

✅ Phase 1: Messenger Core (COMPLETE)

  • 23 files created/updated
  • Database: 5 tables, migrations ready
  • Backend: messaging-service (FastAPI, 9 endpoints + WebSocket)
  • Frontend: Full UI (/messenger route)
  • Infrastructure: docker-compose with 6 services
  • Documentation: 4 complete guides

Status: Production ready, tested, documented

📋 Phase 2: What's Next

🎯 Goal

Make Messenger fully agent-aware:

  • Agents automatically reply to messages
  • Smart filtering (when/which agent responds)
  • Full LLM + Memory integration
  • Real-time agent interactions

🔧 Components to Build

1. agent_filter Service

Purpose: Security & routing layer

Files:

  • services/agent-filter/main.py
  • services/agent-filter/models.py
  • services/agent-filter/rules.py
  • services/agent-filter/config.yaml

Features:

  • Subscribe to NATS messaging.message.created
  • Apply filtering rules (permissions, content, timing)
  • Decide which agent should reply
  • Publish to agent.filter.decision

Time: 1 week

2. DAGI Router Extension

Purpose: Route agent invocations

Changes:

  • Subscribe to agent.filter.decision
  • Create AgentInvocation on "allow"
  • Route to agent-runtime via router.invoke.agent

Time: 3-4 days

3. agent-runtime Service

Purpose: Execute agent logic

Files:

  • services/agent-runtime/main.py
  • services/agent-runtime/llm_client.py
  • services/agent-runtime/messaging_client.py
  • services/agent-runtime/memory_client.py

Features:

  • Subscribe to router.invoke.agent
  • Load agent blueprint
  • Read channel history (last 50 messages)
  • Query Agent Memory (RAG)
  • Call LLM Proxy
  • Post reply to channel

Time: 2 weeks

4. NATS Event Publishing

Purpose: Real event-driven architecture

Changes:

  • messaging-service: Publish actual NATS events
  • matrix-gateway: Publish Matrix events to NATS

Time: 2-3 days

📊 Complete Flow

User types "Hello!" in channel
    ↓
messaging-service → Matrix → NATS: messaging.message.created
    ↓
agent_filter: Check rules
    ↓ (allow)
NATS: agent.filter.decision
    ↓
DAGI Router: Create AgentInvocation
    ↓
NATS: router.invoke.agent
    ↓
agent-runtime:
  1. Read channel history
  2. Query memory
  3. Build prompt
  4. Call LLM
  5. Post reply
    ↓
messaging-service → Matrix → Frontend: Agent reply appears

🔜 Phase 2.5: Agent Hub (Parallel Track)

Can start in parallel with Phase 2 backend work

Frontend Focus

  • 3-column layout (Agents | Chat | Context)
  • Direct channels with agents
  • Reuse Messenger components
  • Context panel (projects, capabilities)

Time: 2 weeks

📁 Documentation Structure

docs/
├── INDEX.md                          ← NEW: Master navigation
├── tasks/
│   ├── README.md                     ← NEW: Tasks overview
│   ├── TASK_PHASE2_AGENT_INTEGRATION.md  ← NEW: Complete spec
│   └── TASK_AGENT_HUB_MVP.md         ← NEW: Complete spec
├── MESSAGING_ARCHITECTURE.md         ← UPDATED: Phase 2 spec
├── MESSENGER_COMPLETE_SPECIFICATION.md
├── messaging-erd.dbml                ← NEW: ERD for dbdiagram.io
└── MESSENGER_TESTING_GUIDE.md

🚀 How to Start

Option A: Use Cursor AI

# 1. Copy complete task
cat docs/tasks/TASK_PHASE2_AGENT_INTEGRATION.md

# 2. Paste into Cursor as single prompt

# 3. Let Cursor implement step-by-step

# 4. Review and test each component

Option B: Manual Implementation

# 1. Read specifications
open docs/tasks/TASK_PHASE2_AGENT_INTEGRATION.md
open docs/MESSAGING_ARCHITECTURE.md

# 2. Start with agent_filter
mkdir -p services/agent-filter
cd services/agent-filter
# Follow task instructions...

# 3. Test each component
docker-compose -f docker-compose.agents.yml up -d

# 4. Move to next component

📝 Acceptance Criteria

Phase 2 Complete When:

  • ✅ Human sends message in channel
  • ✅ agent_filter processes event
  • ✅ DAGI Router creates invocation
  • ✅ agent-runtime generates reply
  • ✅ Agent reply appears in Messenger UI
  • ✅ Agent reply appears in Element
  • ✅ All services pass health checks
  • ✅ E2E test passes (< 5s latency)

Agent Hub Complete When:

  • ✅ /hub route loads without errors
  • ✅ Agent list displays correctly
  • ✅ Direct channel created on agent selection
  • ✅ Chat works (reusing Messenger)
  • ✅ Context panel shows data
  • ✅ Agent replies work in direct channel

🎯 Success Metrics

Metric Target
Agent reply latency < 3s
Agent reply accuracy > 80% helpful
System uptime > 99%
WebSocket latency < 50ms
Database queries < 100ms
Memory queries < 500ms

🔗 Key Files

Specifications

Completed Work

Testing

💡 Implementation Tips

For agent_filter:

  1. Start with basic rules (no agent loops)
  2. Add quiet hours
  3. Add content filtering
  4. Test with mock NATS events

For DAGI Router:

  1. Extend existing router
  2. Add new NATS subscription
  3. Test routing logic separately
  4. Integrate with agent-runtime

For agent-runtime:

  1. Start with mock LLM responses
  2. Add channel history reading
  3. Add memory integration
  4. Add real LLM calls
  5. Add posting back to channel

For Agent Hub:

  1. Start with UI skeleton
  2. Reuse Messenger components
  3. Add backend API
  4. Connect agent integration

🎓 Learning Resources

Understanding the Architecture

Understanding NATS

Understanding Matrix

🔧 Development Environment

Required Services

  • ✅ PostgreSQL (port 5432)
  • ✅ NATS JetStream (port 4222)
  • ✅ Matrix Synapse (port 8008)
  • ✅ messaging-service (port 7004)
  • 🔜 matrix-gateway (port 7003)
  • 🔜 agent-filter (port 7005)
  • 🔜 agent-runtime (port 7006)
  • 🔜 DAGI Router (port TBD)

Docker Stack

# Phase 1 (running)
docker-compose -f docker-compose.messenger.yml up -d

# Phase 2 (to create)
docker-compose -f docker-compose.agents.yml up -d

📅 Timeline

Week 1: agent_filter

  • Days 1-2: Service skeleton
  • Day 3: Rules engine
  • Day 4: NATS integration
  • Day 5: Testing

Week 2: DAGI Router

  • Days 1-2: Router extension
  • Day 3: NATS subscription
  • Days 4-5: Integration testing

Week 3-4: agent-runtime

  • Days 1-3: Service skeleton + channel reading
  • Days 4-6: Memory integration
  • Days 7-8: LLM integration
  • Days 9-10: Posting + testing

Week 5: Integration & Testing

  • Days 1-2: E2E testing
  • Days 3-4: Performance optimization
  • Day 5: Documentation

Week 6: Agent Hub (Parallel)

  • Days 1-2: Backend API
  • Days 3-4: Frontend UI
  • Day 5: Integration + testing

✅ Next Actions

Immediate (Today):

  1. ✅ Review TASK_PHASE2_AGENT_INTEGRATION.md
  2. ✅ Review MESSAGING_ARCHITECTURE.md
  3. ✅ Decide: Cursor AI or manual implementation

This Week:

  1. 🔜 Set up agent-filter service skeleton
  2. 🔜 Create NATS test environment
  3. 🔜 Implement basic filtering rules

Next Week:

  1. 🔜 Extend DAGI Router
  2. 🔜 Start agent-runtime skeleton
  3. 🔜 Begin Agent Hub frontend

🎉 You're Ready!

All specifications are complete. Pick a starting point:

A) Start with agent_filter → TASK_PHASE2
B) Start with Agent Hub UI → TASK_AGENT_HUB
C) Review architecture first → MESSAGING_ARCHITECTURE.md

Status: 📋 All specs ready, waiting for implementation
Version: 1.0.0
Last Updated: 2025-11-24

LET'S BUILD! 🚀

Reference in New Issue View Git Blame Copy Permalink