RCP Production Readiness Roadmap

# Current (broken):
from system.knowledge_base.unified_knowledge_system import UnifiedKnowledgeSystem

# Fixed:
from rcp.system.knowledge_base.unified_knowledge_system import UnifiedKnowledgeSystem

rcp/unified_rcp_system.py
rcp/main.py
rcp/database_enhanced_rcp.py
All files in rcp/system/

packages/rcp/
├── setup.py
├── requirements.txt
├── README.md
└── pyproject.toml

from setuptools import setup, find_packages

setup(
    name="cc-rcp",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[
        "numpy>=1.21.0",
        "torch>=2.0.0",
        "scikit-learn>=1.0.0",
        "scipy>=1.7.0",
        "networkx>=2.6.0",
        # Add all dependencies
    ],
)

"""
DLM-RCP Integration Bridge

Provides seamless integration between DLM and RCP systems,
enabling DLM to use RCP's advanced features.
"""

from typing import Dict, List, Any, Optional
import logging

from rcp.unified_rcp_system import UnifiedRCPSystem
from rcp.system.knowledge_base.unified_knowledge_system import UnifiedKnowledgeSystem
from dlm.core.data_loader import DLMDataLoader

logger = logging.getLogger(__name__)


class RCPBridge:
    """Bridge between DLM and RCP systems"""

    def __init__(self, database_path: str, dlm_config: Any = None):
        """Initialize bridge with both systems"""
        # Initialize DLM
        self.dlm_loader = DLMDataLoader(database_path, config=dlm_config)

        # Initialize RCP
        self.rcp_system = UnifiedRCPSystem(database_path)
        self.rcp_system.initialize_system()

        logger.info("DLM-RCP Bridge initialized")

    def query_with_rcp(self, query: str, use_consolidation: bool = True) -> Dict[str, Any]:
        """
        Query using RCP's cross-conversation understanding

        Returns:
            {
                'response': assembled context,
                'source_conversations': list of conv IDs,
                'confidence': float,
                'knowledge_clusters': cluster IDs used,
            }
        """
        response = self.rcp_system.process_query(query)
        return {
            'response': response.assembled_context,
            'source_conversations': list(response.source_conversations),
            'confidence': response.response_confidence,
            'knowledge_clusters': list(response.knowledge_clusters_used),
        }

    def get_cross_conversation_similar(
        self,
        message_content: str,
        top_k: int = 5
    ) -> List[Dict[str, Any]]:
        """Find similar messages across ALL conversations"""
        return self.rcp_system.context_builder.find_similar_across_conversations(
            message_content,
            top_k
        )

    def get_unified_coordinates(self, message_id: str) -> Dict[str, float]:
        """Get both DLM and RCP coordinates for a message"""
        # Get from DLM
        dlm_graph = self.dlm_loader.load_conversation_by_message(message_id)

        # Get from RCP
        rcp_coords = self.rcp_system.get_message_coordinates(message_id)

        return {
            'dlm': {
                'x': dlm_graph.coordinates.x,
                'y': dlm_graph.coordinates.y,
                'z': dlm_graph.coordinates.z,
                't': dlm_graph.coordinates.t,
            },
            'rcp': {
                'depth': rcp_coords.depth,
                'sibling': rcp_coords.sibling,
                'homogeneity': rcp_coords.homogeneity,
            }
        }

# In DLMEngine.__init__
self.rcp_enabled = config.get('use_rcp', False)
if self.rcp_enabled:
    from dlm.integration.rcp_bridge import RCPBridge
    self.rcp_bridge = RCPBridge(self.database_path, config)
    logger.info("RCP integration enabled")

# Add new search method
def search_with_rcp_consolidation(self, query: str, top_k: int = 10):
    """Search using RCP cross-conversation consolidation"""
    if not self.rcp_enabled:
        raise RuntimeError("RCP not enabled")

    return self.rcp_bridge.query_with_rcp(query)

# Add RCP coordinate integration
def construct_reply_chain_with_rcp(
    self,
    user_input: str,
    use_cross_conversation: bool = True,
    max_history_length: int = 10
):
    """Build reply chain using RCP cross-conversation understanding"""

    if use_cross_conversation and hasattr(self, 'rcp_bridge'):
        # Get similar messages from ALL conversations
        similar_msgs = self.rcp_bridge.get_cross_conversation_similar(
            user_input,
            top_k=max_history_length
        )

        # Build chain from consolidated knowledge
        # ...

    # Fall back to normal chain building
    return self.construct_reply_chain(user_input, max_history_length)

"""
RCP API Endpoints

Exposes RCP functionality via REST API
"""

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from typing import List, Optional

router = APIRouter(prefix="/rcp", tags=["rcp"])


class QueryRequest(BaseModel):
    query: str
    use_consolidation: bool = True
    top_k: int = 10


class QueryResponse(BaseModel):
    response: str
    source_conversations: List[str]
    confidence: float
    knowledge_clusters: List[int]
    processing_time: float


@router.post("/query", response_model=QueryResponse)
async def query_with_rcp(request: QueryRequest):
    """Query using RCP cross-conversation understanding"""
    try:
        result = rcp_bridge.query_with_rcp(
            request.query,
            use_consolidation=request.use_consolidation
        )
        return QueryResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/coordinates/{message_id}")
async def get_message_coordinates(message_id: str):
    """Get unified coordinates for a message"""
    try:
        coords = rcp_bridge.get_unified_coordinates(message_id)
        return coords
    except Exception as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.get("/similar/{message_id}")
async def get_cross_conversation_similar(
    message_id: str,
    top_k: int = 5
):
    """Find similar messages across all conversations"""
    try:
        similar = rcp_bridge.get_cross_conversation_similar(message_id, top_k)
        return {"similar_messages": similar}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

"""
RCP Command Line Interface

Usage:
    python rcp_cli.py query "your question"
    python rcp_cli.py similar message_123
    python rcp_cli.py coordinates message_123
    python rcp_cli.py consolidate --rebuild
"""

import click
from dlm.integration.rcp_bridge import RCPBridge

@click.group()
@click.option('--database', default='conversations.db')
@click.pass_context
def cli(ctx, database):
    """RCP CLI Tool"""
    ctx.obj = RCPBridge(database)

@cli.command()
@click.argument('query')
@click.option('--top-k', default=10)
def query(query, top_k):
    """Query using RCP"""
    bridge = click.get_current_context().obj
    result = bridge.query_with_rcp(query)
    click.echo(f"Response: {result['response']}")
    click.echo(f"Confidence: {result['confidence']:.2f}")
    click.echo(f"Sources: {', '.join(result['source_conversations'])}")

# Add more commands...

if __name__ == '__main__':
    cli()

"""Integration tests for RCP system"""

import pytest
from rcp.unified_rcp_system import UnifiedRCPSystem
from dlm.integration.rcp_bridge import RCPBridge


def test_rcp_initialization():
    """Test RCP system initializes correctly"""
    system = UnifiedRCPSystem('test.db')
    assert system is not None
    assert system.knowledge_system is not None


def test_cross_conversation_consolidation():
    """Test message consolidation across conversations"""
    system = UnifiedRCPSystem('test.db')
    system.initialize_system()

    # Test consolidation
    stats = system.get_system_statistics()
    assert 'total_clusters' in stats
    assert stats['total_clusters'] > 0


def test_rcp_bridge():
    """Test DLM-RCP bridge"""
    bridge = RCPBridge('test.db')

    result = bridge.query_with_rcp("test query")
    assert 'response' in result
    assert 'confidence' in result


def test_coordinate_integration():
    """Test unified coordinate system"""
    bridge = RCPBridge('test.db')

    coords = bridge.get_unified_coordinates('msg_123')
    assert 'dlm' in coords
    assert 'rcp' in coords

# Train IRCP-aware embeddings
./scripts/train_ircp_sentence_transformer.sh conversations.db ./models/ircp_st

# This will:
# 1. Prepare training data from conversations
# 2. Fine-tune sentence transformer with IRCP coordinates
# 3. Save trained model

# In rcp/system/knowledge_base/unified_knowledge_system.py

from sentence_transformers import SentenceTransformer

def __init__(self, database_path: str, embedding_model_path: str = None):
    # Use trained IRCP model if available
    if embedding_model_path:
        self.embedder = SentenceTransformer(embedding_model_path)
    else:
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')

# Production RCP Configuration

system:
  name: "RCP Production"
  log_level: "INFO"
  enable_metrics: true

database:
  path: "${DATABASE_PATH}"
  pool_size: 10
  timeout: 30

rcp:
  enable_consolidation: true
  similarity_threshold: 0.75
  cross_conversation_threshold: 0.65
  max_clusters: 1000
  consolidation_method: "dbscan"

ircp:
  model_path: "${IRCP_MODEL_PATH}"
  embedding_dim: 384
  batch_size: 32
  use_gpu: true

performance:
  cache_size: 10000
  max_query_time: 5.0
  enable_async: true
  worker_threads: 4

monitoring:
  enable_logging: true
  log_queries: true
  track_performance: true
  alert_on_errors: true

# Production Environment Variables

DATABASE_PATH=/data/conversations.db
IRCP_MODEL_PATH=/models/ircp_sentence_transformer
RCP_CONFIG_PATH=/config/production.yaml

LOG_LEVEL=INFO
ENABLE_RCP=true
ENABLE_METRICS=true

API_HOST=[ip]
API_PORT=8000

docs/
├── RCP_PRODUCTION_GUIDE.md      # How to deploy RCP
├── RCP_API_REFERENCE.md          # API documentation
├── RCP_INTEGRATION_GUIDE.md      # How to integrate with DLM
├── RCP_TROUBLESHOOTING.md        # Common issues & solutions
└── RCP_ARCHITECTURE.md            # System architecture