INTEGRATION.md

# COGENBAI Integration Guide

## Component Integration Map

### 1. Core Components
```
cogenbai/core/
├── model.py       # Main AI model (CogenBAI class)
└── config.py      # Configuration management
```
- `model.py` is the central component that integrates with all other modules
- `config.py` provides configuration management used across all components

### 2. API Layer Integration
```
cogenbai/api/
├── server.py      # FastAPI server
└── middleware.py  # Request logging and auth
```
- `server.py` exposes core functionality via REST API
- Connects to core model, language generator, and collaboration features

### 3. Language Support Integration
```
cogenbai/languages/
└── generator.py   # Language-specific code generation
```
- Used by core model for language-specific code generation
- Integrates with templates and modern frameworks

### 4. Collaboration Features
```
cogenbai/collaboration/
├── session.py     # Session management
└── websocket.py   # Real-time collaboration
```
- WebSocket server handles real-time code synchronization
- Session manager tracks active collaboration sessions

### 5. Development Tools
```
cogenbai/
├── debug/         # Code analysis
├── review/        # Code review
└── testing/       # Test generation
```
- All tools integrate with core model via API endpoints
- Share common configuration and language support

## Integration Flow

1. **Startup Sequence**
```python
from cogenbai import CogenBAI, CogenConfig

# Load configuration
config = CogenConfig.load('config.yaml')

# Initialize core model
model = CogenBAI(config)

# Start API server
from cogenbai.api.server import app
import uvicorn
uvicorn.run(app)
```

2. **Code Generation Flow**
```python
# 1. Request comes through API
@app.post("/generate")
async def generate_code(request: CodeRequest):
    
    # 2. Core model handles request
    code = model.generate_code(
        prompt=request.prompt,
        language=request.language
    )
    
    # 3. Language generator processes code
    from cogenbai.languages.generator import LanguageGenerator
    lang_generator = LanguageGenerator()
    formatted_code = lang_generator.format(code, request.language)
    
    return {"code": formatted_code}
```

3. **Collaboration Flow**
```python
# 1. WebSocket connection established
@app.websocket("/ws/{session_id}")
async def websocket_endpoint(websocket: WebSocket, session_id: str):
    
    # 2. Session manager handles connection
    await session_manager.connect(session_id, websocket)
    
    # 3. Real-time updates broadcast to all participants
    await collaboration_manager.broadcast(
        session_id,
        {"type": "update", "data": code_update}
    )
```

## File Paths and Dependencies

All components are installed under the main package:
```
/c:/Users/shahrear/Downloads/cogenbai/
├── cogenbai/           # Main package directory
├── tests/              # Test files
├── Modelfile          # Ollama model definition
├── BUILD.md           # Build instructions
└── INTEGRATION.md     # This file
```

## Configuration Integration

The `config.py` file integrates all components through shared settings:
```yaml
model:
  name: codegen-16B-multi
  device: cuda
  
languages:
  default: python
  supported: [python, javascript, ...]
  
collaboration:
  max_sessions: 100
  timeout: 3600
  
api:
  host: 0.0.0.0
  port: 8000
```

## Testing Integration

Run integrated tests:
```bash
pytest tests/integration/
```

## Monitoring Integration

All components emit metrics:
```python
from cogenbai.monitoring import metrics

# Track model performance
metrics.track_generation_time(duration)

# Monitor API requests
metrics.track_api_request(endpoint, status)

# Log collaboration events
metrics.track_collaboration_session(session_id)
```

## Security Integration

Components share common security features:
- API authentication
- Session validation
- Rate limiting
- Input sanitization

## Production Integration Steps

1. Build the model:
```bash
ollama create cogenbai -f Modelfile
```

2. Start all components:
```bash
# Start API server
uvicorn cogenbai.api.server:app

# Start collaboration server
python -m cogenbai.collaboration.server

# Start monitoring
docker-compose up -d prometheus grafana
```

3. Verify integration:
```bash
curl http://localhost:8000/health
```