MORE FEATURES NEEDED - Docker-compose deployment + Web crawling + Social media ingestion + Graphiti RAG integration Problem Statement

[Kakachia777]

Problem Statement

Currently, ii-agent requires significant manual setup and lacks persistent knowledge capabilities:

• Complex deployment: Users must manually install dependencies, configure databases, set up workspace directories
• Limited data sources: Only web search available, no crawling or social media ingestion
• No knowledge persistence: Agent forgets everything between sessions, no RAG system
• Poor developer experience: Multiple config files, manual API key management, scattered setup steps

Current user journey: Clone repo → Install Python deps → Configure workspace → Set up database → Configure API keys → Debug connection issues → Finally test agent

Desired user journey: Clone repo → docker compose up → Add API keys to .env → Agent ready with crawling + RAG

Proposed Solution

Add comprehensive data ingestion and knowledge management system with containerized deployment.

Core Components

1. Docker Infrastructure

• Full docker-compose stack (agent + UI + postgres + redis + neo4j + graphiti + crawler workers)
• Environment-based configuration
• Volume persistence for data
• Health checks and dependency management

2. Web Crawling System with Crawl4AI

• WebCrawlTool using Crawl4AI v0.5.0 for content extraction
• Deep crawling capabilities with configurable strategies (BFS, DFS, Best-First)
• Memory-Adaptive Dispatcher for large-scale crawls with dynamic concurrency
• LLM-friendly markdown output perfect for RAG pipeline ingestion
• Redis-based job queue for async crawling
• Automatic content deduplication and chunking

3. Social Media Connectors

• Reddit: PRAW-based fetcher for user comments/posts (up to 1000 items API limit)
• Twitter/X: Tweepy v2 integration with rate limit handling
• LinkedIn: Graph API v22 for public posts/analytics
• TikTok: Research API support (graceful 403 handling for non-academic tokens)
• Instagram: Graph API integration
• Other Socials...

4. Graphiti Knowledge Graph Integration

• Neo4j-backed knowledge graph with semantic search and relationship extraction
• Episode-based memory: Stores conversation turns as episodes with automatic fact extraction
• Advanced search capabilities:
  • Reciprocal Rank Fusion (RRF) combining BM25 and semantic search
  • Maximal Marginal Relevance (MMR) for diverse results
  • Cross-encoder reranking with OpenAI or BGE models
• RAGQueryTool for agent to retrieve relevant context with graph relationships
• Session-scoped knowledge with cross-session learning
• Entity relationship mapping between people, topics, and content sources

Technical Implementation

File Structure

├── docker-compose.yml
├── Dockerfile.crawler
├── .env.example
├── src/
│   ├── ii_agent/tools/
│   │   ├── web_crawl_tool.py
│   │   ├── social_ingestion_tool.py
│   │   └── rag_query_tool.py
│   ├── crawler/
│   │   ├── worker.py
│   │   ├── crawl4ai_config.py
│   │   └── processors/
│   ├── social/
│   │   ├── reddit_fetcher.py
│   │   ├── twitter_fetcher.py
│   │   └── linkedin_fetcher.py
│   └── graphiti/
│       ├── client.py
│       └── episode_manager.py

Key APIs

WebCrawlTool (using Crawl4AI deep crawling)

{
  "name": "web_crawl",
  "input": {
    "urls": ["https://example.com"],
    "strategy": "BFS",
    "max_depth": 3,
    "max_pages": 50,
    "url_filters": ["*/blog/*", "*/docs/*"],
    "crawler_mode": "browser"
  }
}

SocialIngestionTool

{
  "name": "social_ingest", 
  "input": {
    "platform": "reddit",
    "count": 500,
    "filters": {"subreddits": ["python", "MachineLearning"]}
  }
}

RAGQueryTool (with Graphiti graph search)

{
  "name": "rag_query",
  "input": {
    "query": "What topics do I comment about most?",
    "search_type": "hybrid",
    "rerank_method": "rrf",
    "include_relationships": true,
    "top_k": 10
  }
}

Graphiti Integration Details

Episode Management

# src/graphiti/episode_manager.py
from graphiti_core import Graphiti
from graphiti_core.nodes import EpisodeType
from graphiti_core.utils.bulk_utils import RawEpisode

class GraphitiEpisodeManager:
    def __init__(self, neo4j_uri, neo4j_user, neo4j_password):
        self.client = Graphiti(neo4j_uri, neo4j_user, neo4j_password)
        
    async def add_crawled_content(self, content, metadata):
        """Add crawled content as episodes to knowledge graph"""
        episode = RawEpisode(
            name=f"crawl_{metadata['url']}",
            episode_type=EpisodeType.CONVERSATION,
            content=content,
            source=metadata['url'],
            reference_time=metadata['timestamp']
        )
        await self.client.add_episode(episode)
        
    async def search_knowledge(self, query, search_type="hybrid"):
        """Search knowledge graph with advanced reranking"""
        results = await self.client.search(
            query=query,
            search_type=search_type,  # "semantic", "bm25", or "hybrid"
            rerank_method="rrf",      # "rrf", "mmr", or "cross_encoder"
            limit=10
        )
        return results

Docker Compose Services

services:
  ii-agent:
    build: .
    environment:
      - DATABASE_URL=postgresql://postgres:password@postgres:5432/iiagent
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USER=neo4j
      - NEO4J_PASSWORD=graphiti_password
      - REDIS_URL=redis://redis:6379
      - CRAWL4AI_MEMORY_THRESHOLD=0.8
    depends_on: [postgres, redis, neo4j, crawl4ai]
    
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: iiagent
      POSTGRES_USER: postgres 
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
      
  redis:
    image: redis:7-alpine
    
  neo4j:
    image: neo4j:5.23
    environment:
      - NEO4J_AUTH=neo4j/graphiti_password
      - NEO4J_PLUGINS=["apoc"]
    ports:
      - "7474:7474"
      - "7687:7687"
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
    
  # Crawl4AI as scalable service
  crawl4ai:
    image: unclecode/crawl4ai:latest
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - CRAWL4AI_API_TOKEN=${CRAWL4AI_API_TOKEN}
    ports:
      - "8001:8000"
    deploy:
      replicas: 2
      
  crawler-worker:
    build: 
      context: .
      dockerfile: Dockerfile.crawler
    environment:
      - CRAWL_QUEUE_URL=redis://redis:6379
      - CRAWL4AI_URL=http://crawl4ai:8000
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USER=neo4j
      - NEO4J_PASSWORD=graphiti_password
    depends_on: [redis, neo4j, crawl4ai]
    deploy:
      replicas: 3

volumes:
  postgres_data:
  neo4j_data:
  neo4j_logs:

Environment Configuration

.env.example

# Core
ANTHROPIC_API_KEY=your_anthropic_key
DATABASE_URL=postgresql://postgres:password@postgres:5432/iiagent

# Neo4j & Graphiti Configuration
NEO4J_URI=bolt://neo4j:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=graphiti_password

# Crawl4AI Configuration  
CRAWL4AI_API_TOKEN=your_crawl4ai_token
CRAWL4AI_MEMORY_THRESHOLD=0.8
CRAWL4AI_MAX_CONCURRENT=10

# Social Media APIs
REDDIT_CLIENT_ID=your_reddit_client_id
REDDIT_CLIENT_SECRET=your_reddit_secret
TWITTER_BEARER_TOKEN=your_twitter_token
LINKEDIN_CLIENT_ID=your_linkedin_id
LINKEDIN_CLIENT_SECRET=your_linkedin_secret

# Optional
TAVILY_API_KEY=your_tavily_key
JINA_API_KEY=your_jina_key

Benefits

• Zero-setup deployment: Single command gets full stack running including Neo4j
• Persistent knowledge graph: Agent builds and maintains relationships between entities
• Advanced search capabilities: RRF, MMR, and cross-encoder reranking for better retrieval
• Rich data sources: Web crawling + social media beyond just web search
• Scalable architecture: Crawl4AI's memory-adaptive dispatcher + Redis queues
• LLM-optimized content: Crawl4AI generates clean markdown perfect for RAG
• Deep crawling capabilities: Explore entire websites with intelligent strategies
• Graph-based memory: Graphiti automatically extracts entities and relationships
• Developer friendly: Standard docker-compose, clear API structure
• Production ready: Health checks, volume persistence, environment configuration

Use Cases Enabled

• Personal knowledge assistant: "Deep crawl my blog and find connections between my ideas"
• Research automation: "Monitor these 50 websites and track how topics evolve"
• Social media analysis: "What topics am I engaging with most and how do they relate?"
• Documentation assistant: "Crawl our docs and understand product relationships"
• Content discovery: "Find unexpected connections between my saved articles and projects"
• Competitive intelligence: "Track competitor content and identify relationship patterns"
• Academic research: "Build knowledge graphs from paper citations and topics"

[Kakachia777]

More stuff that could be fun (and useful) on top of the stack:

scheduled agents
Let the user say “scan these sources every hour and ping me if something new pops up”. A tiny Celery beat or FastAPI BackgroundTasks loop writes into the same event queue.

code-runner sandbox
Firecracker or Docker-in-Docker so the agent can actually compile and execute arbitrary code snippets safely, then return the output.

plugin marketplace
Simple manifest: drop my_tool.whl into a plugins folder, ii-agent auto-loads it. Encourages the community to add niche tools without touching core.

live notebook mode
Stream agent thoughts into a Jupyter-lite frontend so code blocks can be executed or tweaked in real time.

mobile push notifications
Lightweight Firebase cloud-function that pushes when a long-running task finishes or when a scheduled watch-dog sees something important.

interactive code diff view
If the agent edits files, the web UI shows a Git-style diff the user can accept or reject line by line.

and many more...

[Kakachia777]

Problem Statement

Current context and conversation management in ii-agent has severe limitations that prevent effective long-term usage:

• Hard context limit: 120K tokens fills up quickly with crawled content and long conversations
• Arbitrary turn limit: 200 max turns with simple cutoff regardless of conversation value
• Primitive truncation: Simply drops old messages when limit reached, losing important context
• No conversation persistence: Everything forgotten when session ends, no learning between sessions
• No conversation organization: Can't branch, search, or manage multiple conversation threads
• Performance degradation: Response times increase dramatically with longer conversations (>50K tokens = 10-30s)
• Memory inefficiency: Linear memory growth with no optimization or compression
• No smart summarization: Important context gets lost during truncation

Current user experience: Start conversation → Hit context limit → Lose important information → Start over → Repeat

Desired user experience: Continuous conversations → Smart context management → Searchable history → Persistent learning → Performance optimization

Proposed Solution

Implement advanced context management with multi-level memory architecture, intelligent conversation organization, and performance optimization.

Core Components

🧠 Smart Context Compression & Management

Priority: Very High | Effort: High | Impact: Very High

• Hierarchical summarization: Compress old turns into key points while preserving important details
• Importance weighting: Keep critical messages, compress routine exchanges
• Topic clustering: Group related messages and manage context by topic
• Fact extraction: Move key information to permanent knowledge graph storage
• Semantic deduplication: Remove redundant information across conversations

🔄 Multi-Level Memory Architecture

memory_levels:
  working_memory:
    size: "32K tokens"
    duration: "current_conversation"
    strategy: "full_context"
    purpose: "Immediate conversation context"
    
  episodic_memory: 
    size: "500K tokens"
    duration: "session"
    strategy: "summarized_important_events"
    purpose: "Session-level learning and context"
    
  semantic_memory:
    size: "unlimited"
    duration: "permanent" 
    strategy: "knowledge_graph_facts"
    purpose: "Long-term knowledge and relationships"
    
  procedural_memory:
    size: "50K tokens"
    duration: "user_lifetime"
    strategy: "learned_preferences_and_workflows"
    purpose: "User patterns and preferred approaches"

📊 Conversation Threading & Organization

• Conversation branching: Split conversations into focused threads when topics diverge
• Thread merging: Combine insights from multiple related threads
• Topic detection: Automatically detect when to create new threads
• Cross-thread memory: Share relevant context between related conversations
• Project workspaces: Group conversations by project with shared knowledge base

🔍 Advanced Search & Analytics

• Semantic conversation search: Find discussions by meaning, not just keywords
• Temporal search: Locate conversations from specific time periods
• Entity search: Find all mentions of specific people, places, or concepts
• Topic evolution tracking: See how ideas and topics develop over time
• Conversation effectiveness metrics: Identify most helpful exchanges

Technical Implementation

File Structure

├── src/
│   ├── ii_agent/
│   │   ├── context/
│   │   │   ├── advanced_manager.py
│   │   │   ├── compression_strategies.py
│   │   │   ├── memory_layers.py
│   │   │   └── conversation_indexer.py
│   │   ├── conversation/
│   │   │   ├── threading_manager.py
│   │   │   ├── search_engine.py
│   │   │   ├── analytics.py
│   │   │   └── organization.py
│   │   └── tools/
│   │       ├── context_optimization_tool.py
│   │       └── conversation_search_tool.py

Context Optimization Strategies

Adaptive Context Management

class AdaptiveContextManager:
    def __init__(self):
        self.strategies = {
            "research_mode": {
                "context_budget": "150K tokens",
                "retention_strategy": "fact_based",
                "compression_ratio": "3:1",
                "priority": "new_information"
            },
            
            "creative_mode": {
                "context_budget": "100K tokens", 
                "retention_strategy": "narrative_flow",
                "compression_ratio": "2:1",
                "priority": "creative_continuity"
            },
            
            "support_mode": {
                "context_budget": "80K tokens",
                "retention_strategy": "problem_solving", 
                "compression_ratio": "4:1",
                "priority": "solution_context"
            },
            
            "learning_mode": {
                "context_budget": "120K tokens",
                "retention_strategy": "educational_progression",
                "compression_ratio": "2.5:1", 
                "priority": "concept_building"
            }
        }

Context Compression Tool

{
  "name": "optimize_context",
  "input": {
    "strategy": "intelligent_compression",
    "target_size": "32000",
    "preserve_categories": ["recent_exchanges", "key_facts", "user_preferences"],
    "compression_methods": ["summarization", "fact_extraction", "deduplication"]
  }
}

Conversation Search Tool

{
  "name": "search_conversations",
  "input": {
    "query": "machine learning discussions from last month",
    "search_type": "semantic",
    "time_range": {"start": "2024-01-01", "end": "2024-01-31"},
    "include_related": true,
    "max_results": 10
  }
}

Performance Optimization Features

Context Caching System

performance_optimizations = {
  "context_caching": {
    "embeddings_cache": "Cache vector representations of messages",
    "summary_cache": "Cache generated summaries to avoid recomputation", 
    "fact_cache": "Cache extracted facts and entities",
    "response_cache": "Cache responses to similar questions"
  },
  
  "parallel_processing": {
    "async_summarization": "Summarize old context in background",
    "parallel_tool_calls": "Run multiple tools simultaneously",
    "background_indexing": "Index new content while responding",
    "preemptive_compression": "Compress context before limits are reached"
  },
  
  "smart_loading": {
    "lazy_context_loading": "Load context only when needed",
    "progressive_enhancement": "Start with summary, add details if needed",
    "context_pre_warming": "Predict and prepare needed context",
    "selective_retrieval": "Load only relevant portions of conversation history"
  }
}

Database Schema Enhancements

-- Enhanced conversation management
CREATE TABLE conversations (
    id UUID PRIMARY KEY,
    user_id UUID REFERENCES users(id),
    workspace_id UUID REFERENCES workspaces(id),
    title TEXT,
    conversation_type VARCHAR(50), -- research, creative, support, learning
    created_at TIMESTAMP,
    last_active TIMESTAMP,
    token_count INTEGER,
    turn_count INTEGER,
    status VARCHAR(20), -- active, archived, paused, completed
    context_strategy VARCHAR(50),
    importance_score FLOAT DEFAULT 0.0
);

CREATE TABLE conversation_turns (
    id UUID PRIMARY KEY,
    conversation_id UUID REFERENCES conversations(id),
    turn_number INTEGER,
    role VARCHAR(20), -- user, assistant, system
    content TEXT,
    compressed_content TEXT, -- summarized version
    metadata JSONB, -- tool_calls, tokens, timing, importance_score
    embedding_vector vector(1536), -- for semantic search
    created_at TIMESTAMP,
    is_compressed BOOLEAN DEFAULT FALSE
);

CREATE TABLE conversation_summaries (
    id UUID PRIMARY KEY,
    conversation_id UUID REFERENCES conversations(id),
    turn_range_start INTEGER,
    turn_range_end INTEGER,
    summary_text TEXT,
    key_facts JSONB,
    entities JSONB,
    topics JSONB,
    compression_ratio FLOAT,
    created_at TIMESTAMP
);

CREATE TABLE conversation_branches (
    id UUID PRIMARY KEY,
    parent_conversation_id UUID REFERENCES conversations(id),
    branch_conversation_id UUID REFERENCES conversations(id),
    branch_point_turn INTEGER,
    branch_reason TEXT,
    similarity_score FLOAT,
    created_at TIMESTAMP
);

CREATE TABLE conversation_topics (
    id UUID PRIMARY KEY,
    conversation_id UUID REFERENCES conversations(id),
    topic_name VARCHAR(100),
    confidence_score FLOAT,
    turn_range_start INTEGER,
    turn_range_end INTEGER,
    created_at TIMESTAMP
);

CREATE TABLE context_cache (
    id UUID PRIMARY KEY,
    cache_key VARCHAR(255) UNIQUE,
    cache_type VARCHAR(50), -- summary, embedding, fact_extraction
    content JSONB,
    expires_at TIMESTAMP,
    created_at TIMESTAMP
);

Docker Service Additions

# Context management services
context-optimizer:
  build: ./context-optimizer
  environment:
    - DATABASE_URL=${DATABASE_URL}
    - REDIS_URL=${REDIS_URL}
    - EMBEDDING_SERVICE_URL=http://embedding-service:8080
    - CONTEXT_BUDGET=${CONTEXT_BUDGET:-120000}
  depends_on: [postgres, redis, embedding-service]
  deploy:
    replicas: 2

embedding-service:
  image: sentence-transformers/all-MiniLM-L6-v2
  ports:
    - "8080:8080"
  environment:
    - MODEL_NAME=all-MiniLM-L6-v2
    - BATCH_SIZE=32
  
conversation-indexer:
  build: ./indexer
  environment:
    - ELASTICSEARCH_URL=${ELASTICSEARCH_URL}
    - DATABASE_URL=${DATABASE_URL}
    - NEO4J_URI=${NEO4J_URI}
  depends_on: [elasticsearch, postgres, neo4j]
  
elasticsearch:
  image: elasticsearch:8.11.0
  environment:
    - discovery.type=single-node
    - ES_JAVA_OPTS=-Xms1g -Xmx1g
    - xpack.security.enabled=false
  ports:
    - "9200:9200"
  volumes:
    - elasticsearch_data:/usr/share/elasticsearch/data

# Background processing for context optimization    
context-worker:
  build: ./context-worker
  environment:
    - CELERY_BROKER_URL=${REDIS_URL}
    - DATABASE_URL=${DATABASE_URL}
    - BACKGROUND_COMPRESSION=true
  depends_on: [redis, postgres]
  deploy:
    replicas: 3

Environment Configuration

.env additions

# Context Management
CONTEXT_BUDGET=120000
MAX_CONVERSATION_TURNS=1000  # Increased from 200
COMPRESSION_THRESHOLD=0.8    # Compress when 80% of budget used
BACKGROUND_OPTIMIZATION=true

# Search & Indexing
ELASTICSEARCH_URL=http://elasticsearch:9200
ENABLE_SEMANTIC_SEARCH=true
CONVERSATION_INDEXING=true

# Performance
CONTEXT_CACHE_TTL=3600      # Cache timeout in seconds
ENABLE_PARALLEL_PROCESSING=true
PREEMPTIVE_COMPRESSION=true

# Memory Management
WORKING_MEMORY_SIZE=32000
EPISODIC_MEMORY_SIZE=500000
ENABLE_BACKGROUND_COMPRESSION=true

Advanced Features

Conversation Analytics Dashboard

conversation_analytics = {
  "usage_patterns": {
    "peak_usage_times": "When user is most active",
    "conversation_lengths": "Average turns per conversation type",
    "topic_frequency": "Most discussed topics over time",
    "context_efficiency": "How well context is being utilized"
  },
  
  "performance_metrics": {
    "response_times": "Average response time by context size",
    "compression_effectiveness": "Compression ratios and quality scores", 
    "cache_hit_rates": "Effectiveness of caching strategies",
    "memory_usage": "Context memory utilization patterns"
  },
  
  "conversation_insights": {
    "topic_evolution": "How topics develop and branch over time",
    "learning_progression": "User knowledge growth patterns",
    "effectiveness_scores": "Which conversations were most valuable",
    "knowledge_gaps": "Areas where agent struggles"
  }
}

Smart Context Suggestions

# Context Assistant Tool
{
  "name": "context_assistant",
  "features": {
    "relevant_history": "Suggest relevant past conversations for current topic",
    "missing_context": "Identify when important context is missing", 
    "context_conflicts": "Detect contradictions in conversation history",
    "optimal_timing": "Suggest when to branch conversation or summarize",
    "context_health": "Monitor context quality and coherence",
    "compression_preview": "Show what would be compressed before doing it"
  }
}

Conversation Templates & Workflows

conversation_templates:
  research_session:
    initial_context: "Research mode with fact extraction priority"
    context_budget: "150K tokens"
    auto_tools: ["web_crawl", "rag_query", "social_ingest"]
    compression_strategy: "fact_preserving"
    
  creative_writing:
    initial_context: "Creative mode with narrative flow priority"
    context_budget: "100K tokens"
    auto_tools: ["web_search", "rag_query"]
    compression_strategy: "narrative_preserving"
    
  problem_solving:
    initial_context: "Support mode with solution focus"
    context_budget: "80K tokens"
    auto_tools: ["web_search", "rag_query"]
    compression_strategy: "solution_focused"
    
  learning_session:
    initial_context: "Educational mode with concept building"
    context_budget: "120K tokens" 
    auto_tools: ["web_search", "rag_query"]
    compression_strategy: "educational_progression"

Benefits

• Unlimited conversation length: No arbitrary cutoffs, intelligent context management
• Persistent learning: Agent remembers and builds on previous conversations
• Fast performance: Optimized context loading, caching, and compression
• Searchable conversation history: Find any past discussion or piece of information
• Intelligent organization: Automatic conversation threading and topic management
• Adaptive strategies: Context management adapts to conversation type and user patterns
• Performance scalability: Maintains responsiveness regardless of conversation length
• Knowledge accumulation: Agent improves over time with accumulated context and learning

Use Cases Enabled

• Long-term research projects: Maintain context across weeks or months of investigation
• Iterative problem solving: Build on previous attempts and solutions
• Educational conversations: Track learning progress and adapt teaching approach
• Creative projects: Maintain narrative flow and creative continuity
• Technical support: Remember previous issues and solutions for better assistance
• Personal knowledge assistant: Build comprehensive understanding of user preferences and needs

[Kakachia777]

Would be cool to add:

🌐 Local Chrome Profile Browsing, as in "Web-UI" Github project
Profile Integration: Access user's actual Chrome profile, bookmarks, history, saved passwords
Browser Automation: Headless/visible modes, screenshot capture, extension support
Security Features: Permission system, sandboxed browsing, incognito mode

🤖 Multi-Agent System, Pydantic AI, Agno, CrewAI, Langgraph etc.
Specialized Agents: Research, coding, creative, analysis, and coordinator agents
Coordination Mechanisms: Task delegation, parallel processing, result aggregation
Shared Resources: Memory pool, tool access, communication bus

🎯 Advanced Workflow Automation, as in Zapier, n8n...
Smart Triggers: Scheduled tasks, file system events, API webhooks
Template Workflows: Daily research, content publishing, code deployment
Conditional Logic: If-then rules, error handling, approval gates

[khoangothe]

Hi @Kakachia777! Thank you for the suggestions. We just pushed a pull request in #37 that allows you to clone the project -> set up .env files -> docker-compose and you are good to go! We are slowly adding a lot more features for our second release, and your suggestions will really help us. In the mean time, feel free to submit any PRs or discuss any ideas that you think are great.

[Kakachia777]

Thanks for quick response @khoangothe, I wanna truly know, how can I collaborate?

[khoangothe]

We will set up a Discord Server to discuss more soon! In the mean time, feel free to submit any of your ideas as Issues or PRs

[Kakachia777]

Great to know @khoangothe 👌

I'm really interested in your overall plan for RAG implementation. Are you thinking of going with a specific approach, do you have plans for persistent knowledge/memory?

Also, would love to connect and collaborate more directly, when do you think the Discord server will be ready? Will be happy to help push forward on any of the features that would be most useful for your roadmap.

[AI-Manditrade]

For persistent memory, mem0 MCP is very popular. https://github.com/mem0ai/mem0