quantumdrive 1.5.14

QuantumDrive platform and SDK

QuantumDrive

AI-powered assistant and data management platform built on AgentForge.

Start Here

The definitive project handoff and state document is docs/QuantumDrive_Project_Master_Record.md.

If you are a developer or AI coding assistant resuming work, read that document first. It is the canonical source for:

• current project purpose
• implemented vs. planned capabilities
• project history and evolution
• codebase and documentation navigation
• what remains to be built

Additionally, AI coding assistants must record technical insights, architectural decisions, and bug resolutions in docs/LESSONS_LEARNED.md.

If you make meaningful changes to architecture, features, plans, status, or documentation, update docs/QuantumDrive_Project_Master_Record.md in the same work session.

Overview

QuantumDrive is an AlphaSix IP product that provides:

• Q Assistant: Conversational AI with memory and tool access
• Microsoft 365 Integration: SSO and Graph API access
• Vector Storage: Semantic search via AgentFoundry VectorStoreFactory, typically backed by Milvus
• Knowledge Graph: Configurable AgentFoundry KGraph backend, using local DuckDB or hosted Neptune
• AgentForge Integration: Leverages Syntheticore's AgentForge library

Quick Start

Standalone Usage

1. Install dependencies:

   pip install -r requirements.txt
   

   For packaging, license generation, and PQC-related tests, install the build extras:

   make install-build-deps
   

2. Create configuration (choose one):

   Option A: Project root (for development):

   cp resources/default_quantumdrive.toml quantumdrive.toml
   

   Option B: User config directory (for production):

   mkdir -p ~/.config/quantumdrive
   cp resources/default_quantumdrive.toml ~/.config/quantumdrive/quantumdrive.toml
   

3. Set environment variables:

   export AF_OPENAI_API_KEY="sk-..."
   export QD_MS_TENANT_ID="..."
   export QD_MS_CLIENT_ID="..."
   export QD_MS_CLIENT_SECRET="..."
   

4. Generate a development license:

   make generate-license DAYS=30 UNBOUND=1
   

5. Run example:

   python examples/standalone_usage.py
   

Library Usage (from Quantify)

from quantumdrive.core.utils.qd_config import QDConfig
from quantumdrive.core.ai.q_assistant import QAssistant

# Load config from host application
config = QDConfig.from_dict(secrets_dict)

# Initialize assistant
assistant = QAssistant(user_id="user123", org_id="org789", config=config)

# Ask questions
response = assistant.answer_question(
    "What is Python?"
)

Configuration

QuantumDrive uses a flexible configuration system supporting:

• TOML files: For non-sensitive defaults
• Environment variables: For secrets and overrides
• Dependency injection: For library usage

See Configuration Guide for complete documentation.

Knowledge graph deployment options:

• Local deployments: leave AF_KGRAPH.BACKEND="duckdb_sqlite" for a local kgraph.duckdb
• Hosted deployments: set AF_KGRAPH.BACKEND="neptune" and provide the AF_NEPTUNE.* settings
• GitLab integration: set AF_GITLAB.BASE_URL, AF_GITLAB.USERNAME, and AF_GITLAB.TOKEN to enable the GitLab API tools. Use a personal access token, not an account password.

Licensing

QuantumDrive now enforces a signed license at core import time by default.

• QUANTUMDRIVE_ENFORCE_LICENSE=0 disables enforcement for local development and tests
• QUANTUMDRIVE_LICENSE_FILE overrides the resolved quantumdrive.lic path

PQC runtime note:

• QuantumDrive delegates PQC operations to AgentFoundry's kyber provider.
• The current runtime stack is pure Python wheels plus native extensions distributed through pip:
  • pqcrypto
  • pycryptodome
• liboqs-python / oqs is no longer required for QuantumDrive's PQC and license flows.

Build and packaging flow:

make install-build-deps
make generate-license DAYS=30 UNBOUND=1
make build

The wheel packages core/quantumdrive.lic and core/quantumdrive.pem, and core/__init__.py verifies the license on import. The bundled license is an unbound 30-day trial generated at build time and can be overridden by placing a different signed quantumdrive.lic in a higher-priority lookup location.

Required Configuration

QuantumDrive (QD_ prefix)*:

• QD_MS_TENANT_ID - Microsoft Entra ID tenant
• QD_MS_CLIENT_ID - Application client ID
• QD_MS_CLIENT_SECRET - Application secret
• QD_MS_REDIRECT_URI - OAuth callback URL

AgentForge (AF_ prefix)*:

• AF_OPENAI_API_KEY - OpenAI API key
• AF_LLM_PROVIDER - LLM provider (openai, ollama, xai)
• AF_OPENAI_MODEL - Model name (gpt-5.1, gpt-5.1-codex, etc.)

Architecture

┌─────────────────────────────────────────┐
│         Quantify (AlphaSix IP)          │
│  - Web application                      │
│  - Secrets management                   │
│  - User interface                       │
└──────────────┬──────────────────────────┘
               │ config dict
               ↓
┌─────────────────────────────────────────┐
│      QuantumDrive (AlphaSix IP)         │
│  - Q Assistant                          │
│  - Microsoft 365 integration            │
│  - Vector storage                       │
│  - Configuration bridge                 │
└──────────────┬──────────────────────────┘
               │ AF_* config
               ↓
┌─────────────────────────────────────────┐
│     AgentForge (Syntheticore IP)        │
│  - LLM orchestration                    │
│  - Tool registry                        │
│  - Memory management                    │
│  - Vector stores                        │
└─────────────────────────────────────────┘

Components

Q Assistant (core/ai/q_assistant.py)

Conversational AI assistant with:

• Multi-turn conversations with memory
• Tool access (search, calculations, APIs)
• Identity-scoped memory (user, thread, org)
• Crew-based multi-agent workflows

Microsoft 365 Provider (core/auth/microsoft_365_provider.py)

OAuth2 authentication and Graph API access:

• SSO with Microsoft Entra ID
• Token caching and refresh
• User profile retrieval
• Graph API requests

Configuration (core/utils/qd_config.py)

Flexible configuration management:

• TOML file loading
• Environment variable overrides
• Dependency injection support
• AgentForge config extraction

Development

Project Structure

quantumdrive/
├── core/
│   ├── ai/              # Q Assistant and agent configuration
│   ├── auth/            # Microsoft 365 authentication
│   ├── aws/             # AWS Secrets Manager integration
│   ├── ingest/          # Document processing
│   ├── user/            # User profiles
│   └── utils/           # Configuration and utilities
├── docs/                # Documentation
├── examples/            # Usage examples
├── resources/           # Default configuration files
├── tests/               # Test suite
└── webapp/              # Flask web application

Running Tests

python3 -m pytest tests/

Code Style

# Format code
black core/ tests/

# Lint
flake8 core/ tests/

# Type check
mypy core/

Documentation

• Configuration Guide - Complete configuration reference
• AgentForge Configuration - AgentForge settings
• Resources README - Configuration file documentation

Security

Never commit secrets to version control!

• Use environment variables for API keys and credentials
• Use secrets managers (AWS Secrets Manager, Azure Key Vault) in production
• Add .env files to .gitignore
• Rotate exposed credentials immediately

See Configuration Guide for details.

License

Proprietary - AlphaSix IP

Support

For issues or questions, contact the AlphaSix development team.