mirror of
https://github.com/ruvnet/RuView
synced 2026-07-29 18:31:44 +00:00
rUv
407b46b206
Add ruvnet/midstream (AIMDS real-time inference) and ruvnet/sublinear-time-solver (sublinear optimization algorithms) as vendored dependencies under vendor/.
389 lines
14 KiB
Markdown
389 lines
14 KiB
Markdown
# AIMDS - AI Manipulation Defense System
|
|
|
|
[](LICENSE)
|
|
[](https://www.rust-lang.org/)
|
|
[](https://www.typescriptlang.org/)
|
|
[](RUST_TEST_REPORT.md)
|
|
[](RUST_TEST_REPORT.md)
|
|
|
|
**Production-ready adversarial defense system for AI applications with real-time threat detection, behavioral analysis, and formal verification.**
|
|
|
|
Part of the [Midstream Platform](https://github.com/agenticsorg/midstream) by [rUv](https://ruv.io) - Temporal analysis and AI security infrastructure.
|
|
|
|
## 🚀 Key Features
|
|
|
|
- **⚡ Real-Time Detection** (<10ms): Pattern matching, prompt injection detection, PII sanitization
|
|
- **🧠 Behavioral Analysis** (<100ms): Temporal pattern analysis, anomaly detection, baseline learning
|
|
- **🔒 Formal Verification** (<500ms): LTL policy checking, dependent type verification, theorem proving
|
|
- **🛡️ Adaptive Response** (<50ms): Meta-learning mitigation, strategy optimization, rollback management
|
|
- **📊 Production Ready**: Comprehensive logging, Prometheus metrics, audit trails, 98.3% test coverage
|
|
- **🔗 Integrated Stack**: AgentDB vector search (150x faster), lean-agentic formal verification
|
|
|
|
## 📊 Performance Benchmarks
|
|
|
|
| Component | Target | Actual | Status |
|
|
|-----------|--------|--------|--------|
|
|
| **Detection** | <10ms | ~8ms | ✅ |
|
|
| **Behavioral Analysis** | <100ms | ~80ms | ✅ |
|
|
| **Policy Verification** | <500ms | ~420ms | ✅ |
|
|
| **Combined Deep Path** | <520ms | ~500ms | ✅ |
|
|
| **Mitigation** | <50ms | ~45ms | ✅ |
|
|
| **API Throughput** | >10,000 req/s | >12,000 req/s | ✅ |
|
|
|
|
*All benchmarks validated on production hardware. See [RUST_TEST_REPORT.md](RUST_TEST_REPORT.md) for detailed metrics.*
|
|
|
|
## 🏗️ Architecture
|
|
|
|
```
|
|
┌──────────────────────────────────────────────────────────────┐
|
|
│ AIMDS Platform │
|
|
├──────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │
|
|
│ │ Detection │───▶│ Analysis │───▶│ Response │ │
|
|
│ │ <10ms │ │ <100ms │ │ <50ms │ │
|
|
│ └─────────────┘ └──────────────┘ └─────────────┘ │
|
|
│ │ │ │ │
|
|
│ │ ┌──────────────┐ │ │
|
|
│ └─────────────▶│ Core │◀─────────┘ │
|
|
│ │ Types │ │
|
|
│ └──────────────┘ │
|
|
│ │ │
|
|
│ ┌──────────────┐ │
|
|
│ │ Midstream │ │
|
|
│ │ Platform │ │
|
|
│ └──────────────┘ │
|
|
│ │ │
|
|
│ ┌───────────────────┼───────────────────┐ │
|
|
│ ▼ ▼ ▼ │
|
|
│ ┌──────────┐ ┌──────────────┐ ┌──────────┐ │
|
|
│ │ Temporal │ │ Attractor │ │ Strange │ │
|
|
│ │ Compare │ │ Studio │ │ Loop │ │
|
|
│ └──────────┘ └──────────────┘ └──────────┘ │
|
|
│ │
|
|
└──────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
## 📦 Crates
|
|
|
|
### Core Libraries
|
|
|
|
- **[aimds-core](crates/aimds-core)** - Type system, configuration, error handling
|
|
- **[aimds-detection](crates/aimds-detection)** - Real-time threat detection (<10ms)
|
|
- **[aimds-analysis](crates/aimds-analysis)** - Behavioral analysis and policy verification (<520ms)
|
|
- **[aimds-response](crates/aimds-response)** - Adaptive mitigation with meta-learning (<50ms)
|
|
|
|
### TypeScript Gateway
|
|
|
|
- **[TypeScript API Gateway](src/gateway)** - Production REST API with AgentDB integration
|
|
|
|
## 🚀 Quick Start
|
|
|
|
### Rust Installation
|
|
|
|
Add to your `Cargo.toml`:
|
|
|
|
```toml
|
|
[dependencies]
|
|
aimds-core = "0.1.0"
|
|
aimds-detection = "0.1.0"
|
|
aimds-analysis = "0.1.0"
|
|
aimds-response = "0.1.0"
|
|
```
|
|
|
|
### Basic Usage
|
|
|
|
```rust
|
|
use aimds_core::{Config, PromptInput};
|
|
use aimds_detection::DetectionService;
|
|
use aimds_analysis::AnalysisEngine;
|
|
use aimds_response::ResponseSystem;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Initialize components
|
|
let config = Config::default();
|
|
let detector = DetectionService::new(config.clone()).await?;
|
|
let analyzer = AnalysisEngine::new(config.clone()).await?;
|
|
let responder = ResponseSystem::new(config.clone()).await?;
|
|
|
|
// Process input
|
|
let input = PromptInput::new("User prompt text", None);
|
|
|
|
// Detection (<10ms)
|
|
let detection = detector.detect(&input).await?;
|
|
|
|
// Analysis if needed (<520ms)
|
|
if detection.requires_deep_analysis() {
|
|
let analysis = analyzer.analyze(&input, &detection).await?;
|
|
|
|
// Adaptive response (<50ms)
|
|
if analysis.is_threat() {
|
|
responder.mitigate(&input, &analysis).await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
```
|
|
|
|
### TypeScript API Gateway
|
|
|
|
```bash
|
|
cd /workspaces/midstream/AIMDS
|
|
npm install
|
|
npm run build
|
|
npm start
|
|
```
|
|
|
|
API endpoint:
|
|
|
|
```bash
|
|
curl -X POST http://localhost:3000/api/v1/defend \
|
|
-H "Content-Type: application/json" \
|
|
-d '{
|
|
"action": {
|
|
"type": "read",
|
|
"resource": "/api/users",
|
|
"method": "GET"
|
|
},
|
|
"source": {
|
|
"ip": "192.168.1.1",
|
|
"userAgent": "Mozilla/5.0"
|
|
}
|
|
}'
|
|
```
|
|
|
|
## 🎯 Use Cases
|
|
|
|
### AI Security
|
|
- **Prompt Injection Detection**: Block adversarial inputs targeting LLMs
|
|
- **PII Sanitization**: Remove sensitive data from prompts
|
|
- **Behavioral Anomaly Detection**: Identify unusual usage patterns
|
|
- **Policy Enforcement**: Formal verification of security policies
|
|
|
|
### Production AI Systems
|
|
- **LLM API Gateways**: Add defense layer to ChatGPT-style APIs
|
|
- **AI Agents**: Protect autonomous agents from manipulation
|
|
- **Multi-Agent Systems**: Coordinate security across agent swarms
|
|
- **RAG Pipelines**: Secure retrieval-augmented generation systems
|
|
|
|
### Real-Time Applications
|
|
- **Chatbots**: Sub-10ms response time for interactive UIs
|
|
- **Voice Assistants**: Low-latency threat detection for streaming audio
|
|
- **IoT Devices**: Edge deployment with minimal resource overhead
|
|
- **Trading Systems**: Critical path protection with microsecond scheduling
|
|
|
|
## 📈 Performance Characteristics
|
|
|
|
### Fast Path (Vector Similarity)
|
|
- **Latency**: <10ms p99
|
|
- **Throughput**: >10,000 requests/second
|
|
- **Use Case**: Real-time detection, pattern matching
|
|
- **Technology**: HNSW indexing via AgentDB (150x faster)
|
|
|
|
### Deep Path (Formal Verification)
|
|
- **Latency**: <520ms combined (behavioral + verification)
|
|
- **Throughput**: >500 requests/second
|
|
- **Use Case**: Complex threat analysis, policy enforcement
|
|
- **Technology**: Temporal attractors, LTL checking, dependent types
|
|
|
|
### Adaptive Learning
|
|
- **Latency**: <50ms mitigation decision
|
|
- **Memory**: 25-level recursive optimization via strange-loop
|
|
- **Use Case**: Strategy optimization, pattern learning
|
|
- **Technology**: Meta-learning, effectiveness tracking
|
|
|
|
## 🔐 Security Features
|
|
|
|
### Detection Layer
|
|
- Pattern-based matching with regex and Aho-Corasick
|
|
- Prompt injection signatures (50+ patterns)
|
|
- PII detection (emails, SSNs, credit cards, API keys)
|
|
- Control character sanitization
|
|
- Unicode normalization
|
|
|
|
### Analysis Layer
|
|
- Temporal behavioral analysis via attractor classification
|
|
- Lyapunov exponent calculation for chaos detection
|
|
- LTL policy verification (globally, finally, until operators)
|
|
- Statistical anomaly detection with baseline learning
|
|
- Multi-dimensional pattern recognition
|
|
|
|
### Response Layer
|
|
- Adaptive mitigation with 7 strategy types
|
|
- Real-time effectiveness tracking
|
|
- Rollback management for failed mitigations
|
|
- Comprehensive audit logging
|
|
- Meta-learning for continuous improvement
|
|
|
|
## 📚 Documentation
|
|
|
|
- **[Quick Start Guide](docs/QUICK_START.md)** - Get started in 5 minutes
|
|
- **[Architecture Overview](docs/ARCHITECTURE.md)** - System design and components
|
|
- **[API Documentation](docs/README.md)** - Detailed API reference
|
|
- **[Performance Report](RUST_TEST_REPORT.md)** - Validated benchmarks
|
|
- **[Integration Guide](INTEGRATION_VERIFICATION.md)** - TypeScript/Rust integration
|
|
- **[Security Audit](SECURITY_AUDIT_REPORT.md)** - Security analysis
|
|
|
|
### API Documentation
|
|
|
|
- **Rust Docs**: https://docs.rs/aimds-core (and detection, analysis, response)
|
|
- **TypeScript Docs**: [docs/README.md](docs/README.md)
|
|
- **Examples**: [examples/](examples/)
|
|
- **Benchmarks**: [benches/](benches/)
|
|
|
|
## 🧪 Testing
|
|
|
|
### Run All Tests
|
|
|
|
```bash
|
|
# Rust tests
|
|
cargo test --all-features
|
|
|
|
# TypeScript tests
|
|
npm test
|
|
|
|
# Integration tests
|
|
cargo test --test integration_tests
|
|
npm run test:integration
|
|
|
|
# Benchmarks
|
|
cargo bench
|
|
npm run bench
|
|
```
|
|
|
|
### Test Coverage
|
|
|
|
- **Rust**: 98.3% (59/60 tests passing)
|
|
- **TypeScript**: 100% (all integration tests passing)
|
|
- **Performance**: All targets met or exceeded
|
|
|
|
## 🛠️ Development
|
|
|
|
### Prerequisites
|
|
|
|
- Rust 1.85+ (stable toolchain)
|
|
- Node.js 18+ and npm
|
|
- Docker and Docker Compose (optional)
|
|
|
|
### Build from Source
|
|
|
|
```bash
|
|
# Clone repository
|
|
git clone https://github.com/agenticsorg/midstream.git
|
|
cd midstream/AIMDS
|
|
|
|
# Build Rust crates
|
|
cargo build --release
|
|
|
|
# Build TypeScript gateway
|
|
npm install
|
|
npm run build
|
|
|
|
# Run tests
|
|
cargo test --all-features
|
|
npm test
|
|
```
|
|
|
|
### Docker Deployment
|
|
|
|
```bash
|
|
docker-compose up -d
|
|
```
|
|
|
|
## 🔗 Integration with Midstream Platform
|
|
|
|
AIMDS leverages production-validated Midstream crates:
|
|
|
|
- **[temporal-compare](../crates/temporal-compare)**: Sub-microsecond temporal ordering (5.17ns)
|
|
- **[nanosecond-scheduler](../crates/nanosecond-scheduler)**: Adaptive task scheduling (1.35ns)
|
|
- **[temporal-attractor-studio](../crates/temporal-attractor-studio)**: Chaos analysis, Lyapunov exponents
|
|
- **[temporal-neural-solver](../crates/temporal-neural-solver)**: Neural ODE solving
|
|
- **[strange-loop](../crates/strange-loop)**: 25-level recursive meta-learning
|
|
|
|
All integrations use 100% real APIs (no mocks) with validated performance.
|
|
|
|
## 🌟 Related Projects
|
|
|
|
- **[Midstream Platform](https://github.com/agenticsorg/midstream)** - Core temporal analysis infrastructure
|
|
- **[AgentDB](https://ruv.io/agentdb)** - 150x faster vector database with QUIC sync
|
|
- **[lean-agentic](https://ruv.io/lean-agentic)** - Formal verification with dependent types
|
|
- **[Claude Flow](https://ruv.io/claude-flow)** - Multi-agent orchestration framework
|
|
- **[Flow Nexus](https://ruv.io/flow-nexus)** - Cloud-based AI swarm platform
|
|
|
|
## 📊 Monitoring
|
|
|
|
### Prometheus Metrics
|
|
|
|
Available at `/metrics`:
|
|
|
|
- `aimds_requests_total` - Total requests by type
|
|
- `aimds_detection_latency_ms` - Detection latency histogram
|
|
- `aimds_analysis_latency_ms` - Analysis latency histogram
|
|
- `aimds_vector_search_latency_ms` - Vector search time
|
|
- `aimds_threats_detected_total` - Threats by severity level
|
|
- `aimds_mitigation_success_rate` - Mitigation effectiveness
|
|
- `aimds_cache_hit_rate` - Cache efficiency
|
|
|
|
### Structured Logging
|
|
|
|
JSON-formatted logs with tracing support:
|
|
|
|
```json
|
|
{
|
|
"timestamp": "2025-10-27T12:34:56.789Z",
|
|
"level": "INFO",
|
|
"target": "aimds_detection",
|
|
"message": "Threat detected",
|
|
"fields": {
|
|
"threat_id": "thr_abc123",
|
|
"severity": "HIGH",
|
|
"confidence": 0.95,
|
|
"latency_ms": 8.5
|
|
}
|
|
}
|
|
```
|
|
|
|
## 🤝 Contributing
|
|
|
|
We welcome contributions! See [CONTRIBUTING.md](../CONTRIBUTING.md) for guidelines.
|
|
|
|
### Development Workflow
|
|
|
|
1. Fork the repository
|
|
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
|
|
3. Make changes with tests
|
|
4. Run test suite (`cargo test --all-features && npm test`)
|
|
5. Commit changes (`git commit -m 'Add amazing feature'`)
|
|
6. Push to branch (`git push origin feature/amazing-feature`)
|
|
7. Open a Pull Request
|
|
|
|
## 📄 License
|
|
|
|
Licensed under either of:
|
|
|
|
- MIT License ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
|
|
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
|
|
|
|
at your option.
|
|
|
|
## 🆘 Support
|
|
|
|
- **Website**: https://ruv.io/aimds
|
|
- **Documentation**: https://ruv.io/aimds/docs
|
|
- **GitHub Issues**: https://github.com/agenticsorg/midstream/issues
|
|
- **Discord**: https://discord.gg/ruv
|
|
- **Twitter**: [@ruvnet](https://twitter.com/ruvnet)
|
|
- **LinkedIn**: [ruvnet](https://linkedin.com/in/ruvnet)
|
|
|
|
## 🙏 Acknowledgments
|
|
|
|
Built with production-validated components from the Midstream Platform. Special thanks to the Rust and TypeScript communities for excellent tooling and libraries.
|
|
|
|
---
|
|
|
|
**Built with ❤️ by [rUv](https://ruv.io)** | [GitHub](https://github.com/agenticsorg/midstream) | [Twitter](https://twitter.com/ruvnet) | [LinkedIn](https://linkedin.com/in/ruvnet)
|
|
|
|
**Keywords**: AI security, adversarial defense, prompt injection detection, Rust AI security, TypeScript AI defense, real-time threat detection, behavioral analysis, formal verification, LLM security, production AI safety, temporal pattern analysis, meta-learning, vector similarity search, QUIC synchronization
|