# Ai Synthetic Data Generator (`ruv/ai-synthetic-data-generator`) Actor
Generate unlimited, high-quality synthetic data for training AI models, testing systems, and building robust agentic applications
- **URL**: https://apify.com/ruv/ai-synthetic-data-generator.md
- **Developed by:** [Reuven Cohen](https://apify.com/ruv) (community)
- **Categories:** Agents, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.01 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
Agentic Synth
Enterprise-Grade Simulation Engine with Self-Learning AI
***
### Overview
Agentic Synth is a self-learning simulation engine that generates realistic synthetic data at scale. Unlike static generators that produce random values, this engine learns from every run—extracting patterns from your data to improve quality over time. Generate 100 records in 1ms or 50,000 records in 215ms across **37 different domains**.
**Self-Learning Neural Architecture (SONA)** powers the engine with three learning tiers:
| Tier | What It Does | Example |
|------|--------------|---------|
| **Instant** | Learns patterns during generation | "Electronics products cluster around $200-500" |
| **Background** | Trains on batch completion | "Bloomberg buy ratings correlate with sector performance" |
| **Deep** | Cross-session pattern retention | "Medical diagnoses improve ICD-10 code accuracy over time" |
The engine extracts data-type specific patterns: price distributions correlate with product categories, analyst recommendations match rating distributions, medical billing codes align with procedures, and supply chain lead times reflect regional logistics.
**Key Capabilities:**
- **150x faster** than JavaScript generators (Rust/WASM powered by RuVector)
- **5 embedding models** for semantic search (all-MiniLM-L6-v2, bge-small, all-mpnet, e5-small, gte-small)
- **Real brand matching** per category (Samsung for Electronics, Nike for Sports, LEGO for Toys)
- **Consistent data logic** (stock counts match availability, shipping prices match free flags)
- **Neural pattern training** per data type with EWC++ memory protection
For developers, it eliminates rate limits and captchas. For enterprises, it provides compliant test data without legal risks. For AI teams, it generates unlimited training data with semantic embeddings.
The simulation mode streams data in batches—push 50 records every 2 seconds for real-time pipeline testing. Seeds ensure reproducible results for CI/CD. Pairs with [AI Memory Engine](https://apify.com/ruv/ai-memory-engine) for semantic search and RAG applications.
**Benchmarks:** 100 records in 1ms | 1,000 in 7ms | 10,000 in 53ms | 50,000 in 215ms (232K records/sec)
***
### What's New in v3.0
- **4 Tier-1 Premium APIs**: Bloomberg, ZoomInfo, FactSet, LSEG/Reuters clones ($70K+/year value)
- **5 Biosignal/Security**: EEG brainwaves, CGM glucose, SIEM logs, threat intel, NetFlow
- **5 Industrial/Scientific**: SCADA, LiDAR, CAN bus, genomic VCF, satellite imagery
- **5 Exotic/Research**: fMRI brain scans, protein PDB, power grid, AIS maritime, radar
- **Crunchbase Clone**: Real company data via Gemini Grounding API with web search
- **Memory Session Persistence**: Cross-session data sharing between actors
- **37 total data types** covering web, finance, healthcare, security, industrial, and scientific domains
***
### 37 Data Types - Complete Reference
#### Core Web Data (10 types)
| Type | Description | Use Case |
|------|-------------|----------|
| `ecommerce` | Amazon/eBay style products, reviews, sellers | Scraper testing |
| `social` | Twitter/TikTok posts, likes, comments | Social dashboards |
| `jobs` | LinkedIn/Indeed listings, salaries | Job board testing |
| `real_estate` | Zillow properties, addresses, prices | Real estate apps |
| `search_results` | Google SERPs, snippets, rankings | SEO tools |
| `news` | Articles, authors, engagement | News aggregators |
| `api_response` | REST API mock responses, pagination | Backend mocking |
| `timeseries` | Time-stamped metrics, trends | IoT dashboards |
| `events` | Page views, clicks, form submissions | Analytics testing |
| `embeddings` | Vector data (384-768 dimensions) | ML/RAG training |
#### Tier 1: Ultra-Premium Financial APIs (4 types) - $70K+/year value
| Type | Real API Cost | What You Get |
|------|---------------|--------------|
| `bloomberg` | $24-32K/year | Full terminal data: quotes, fundamentals, analytics, news, consensus |
| `zoominfo` | $15K+/year | B2B contacts, technographics, intent signals, org charts |
| `factset` | $12K/year | Financial analytics, estimates, ownership, supply chain |
| `lseg` | $3.6-22K/year | Reuters news, M\&A deals, ESG scores, analyst research |
#### Priority 1: Biosignal & Security (5 types)
| Type | Description | Real-World Application |
|------|-------------|------------------------|
| `eeg` | 5-band neural oscillations, 10-20 electrode system | BCI research, wellness apps |
| `cgm` | Continuous glucose with meal events, trends | Diabetes management ML |
| `siem` | Security events, MITRE ATT\&CK, correlations | SOC training, SIEM testing |
| `threat_intel` | IOCs (IPs, domains, hashes), malware families | Threat detection ML |
| `netflow` | Network flows, 5-tuple, application detection | Network security analysis |
#### Priority 2: Industrial & Scientific (5 types)
| Type | Description | Real-World Application |
|------|-------------|------------------------|
| `scada` | PLC registers, process variables, OPC UA format | Digital twin development |
| `lidar` | 3D point clouds, object detection, bounding boxes | Autonomous vehicle ML |
| `canbus` | Vehicle ECU messages, DBC signals | Automotive development |
| `genomic_vcf` | Genetic variants, annotations, population frequencies | Bioinformatics pipelines |
| `satellite` | Multi-spectral bands, NDVI, cloud masks | Remote sensing analysis |
#### Priority 3: Exotic & Research (5 types)
| Type | Description | Real-World Application |
|------|-------------|------------------------|
| `fmri` | BOLD signal voxels, connectivity matrices | Neuroscience research |
| `protein_pdb` | Molecular 3D structures, binding sites | Drug discovery ML |
| `power_grid` | 3-phase electrical, PMU phasors, harmonics | Grid simulation |
| `ais` | Maritime ship tracking, collision risk | Logistics optimization |
| `radar` | Weather reflectivity, vehicle detection | Autonomous systems |
#### Enterprise & Healthcare (4 types)
| Type | Description | Use Case |
|------|-------------|----------|
| `medical` | Patient records, ICD-10, billing | EHR testing |
| `company` | Org structure, financials, leadership | CRM development |
| `supply_chain` | Shipments, inventory, logistics | SCM systems |
| `financial` | Transactions, accounts, fraud detection | Banking apps |
#### Utility Types (2 types)
| Type | Description | Use Case |
|------|-------------|----------|
| `structured` | Custom schema definition | Any specialized need |
| `demo` | Mix of all types | Quick exploration |
***
### Quick Start
#### Basic Usage
```json
{ "dataType": "demo", "count": 100 }
```
#### Premium Financial Data
```json
{ "dataType": "bloomberg", "count": 500 }
```
#### Biosignal Streaming
```json
{ "dataType": "eeg", "count": 1000 }
```
#### Security Operations
```json
{ "dataType": "siem", "count": 500 }
```
#### Industrial Telemetry
```json
{ "dataType": "scada", "count": 200 }
```
***
### Tutorials
#### Tutorial 1: Bloomberg Terminal Alternative
Generate enterprise-grade financial data worth $24K/year:
```json
{
"dataType": "bloomberg",
"count": 1000,
"seed": "financial-test-v1"
}
```
**Sample Output:**
```json
{
"terminalId": "BBG1734012345678",
"security": {
"ticker": "AAPL",
"name": "Apple Inc",
"assetClass": "equity",
"sector": "Technology",
"exchange": "NASDAQ"
},
"pricing": {
"last": 178.50,
"bid": 178.45,
"ask": 178.55,
"volume": 45000000,
"vwap": 177.82
},
"fundamentals": {
"marketCap": "2.8T",
"peRatio": 28.5,
"eps": 6.26,
"dividendYield": 0.52
},
"analytics": {
"beta": 1.25,
"volatility": 22.5,
"sharpeRatio": 1.45
},
"consensus": {
"recommendation": "buy",
"targetPrice": 210.00,
"numAnalysts": 45
}
}
```
#### Tutorial 2: EEG Brainwave Data for BCI Research
Generate neural oscillation data for brain-computer interface development:
```json
{
"dataType": "eeg",
"count": 500,
"seed": "bci-research-v1"
}
```
**Sample Output:**
```json
{
"sessionId": "EEG_1734012345678",
"samplingRate": 250,
"channels": ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2"],
"epoch": {
"startTime": "2024-12-14T10:30:00Z",
"duration": 4000,
"samples": 1000
},
"bands": {
"delta": { "power": 15.2, "range": "0.5-4Hz" },
"theta": { "power": 8.7, "range": "4-8Hz" },
"alpha": { "power": 25.3, "range": "8-13Hz" },
"beta": { "power": 12.1, "range": "13-30Hz" },
"gamma": { "power": 5.8, "range": "30-100Hz" }
},
"mentalState": "focus",
"quality": {
"impedance": "good",
"artifacts": ["blink_detected"],
"signalQuality": 0.92
}
}
```
#### Tutorial 3: SIEM Security Logs for SOC Training
Generate realistic security event logs with MITRE ATT\&CK mapping:
```json
{
"dataType": "siem",
"count": 1000,
"seed": "soc-training-v1"
}
```
**Sample Output:**
```json
{
"eventId": "SIEM_1734012345678",
"timestamp": "2024-12-14T10:30:45.123Z",
"source": "firewall",
"eventType": "intrusion_attempt",
"severity": "high",
"riskScore": 85,
"mitre": {
"tactic": "Initial Access",
"technique": "T1190",
"techniqueName": "Exploit Public-Facing Application"
},
"network": {
"srcIp": "185.234.xx.xx",
"dstIp": "10.0.1.50",
"srcPort": 45678,
"dstPort": 443,
"protocol": "TCP"
},
"enrichment": {
"geoLocation": "Russia",
"threatIntel": "known_scanner",
"asn": "AS12345"
},
"incident": {
"correlated": true,
"incidentId": "INC-2024-1234",
"attackChain": ["reconnaissance", "initial_access"]
}
}
```
#### Tutorial 4: LiDAR Point Clouds for Autonomous Vehicles
Generate 3D point cloud data for perception system development:
```json
{
"dataType": "lidar",
"count": 100,
"seed": "av-perception-v1"
}
```
**Sample Output:**
```json
{
"frameId": "LIDAR_1734012345678",
"timestamp": "2024-12-14T10:30:00.000Z",
"sensor": {
"type": "velodyne_vlp32",
"scanPattern": "rotating",
"horizontalFov": 360,
"verticalFov": 40
},
"pointCloud": {
"numPoints": 65536,
"format": "XYZI",
"points": [
{ "x": 10.5, "y": 2.3, "z": 0.8, "intensity": 45, "classification": "vehicle" },
{ "x": 15.2, "y": -1.1, "z": 1.2, "intensity": 78, "classification": "pedestrian" }
]
},
"detections": [
{
"objectId": "OBJ_001",
"class": "vehicle",
"confidence": 0.95,
"boundingBox": { "x": 10.5, "y": 2.3, "z": 0.8, "length": 4.5, "width": 1.8, "height": 1.5 },
"velocity": { "vx": 12.5, "vy": 0.1, "vz": 0 }
}
]
}
```
#### Tutorial 5: Threat Intelligence IOC Feeds
Generate malware IOCs and threat actor data for security ML:
```json
{
"dataType": "threat_intel",
"count": 500,
"seed": "threat-ml-v1"
}
```
**Sample Output:**
```json
{
"iocId": "IOC_1734012345678",
"type": "ip",
"value": "185.234.xx.xx",
"threatType": "c2_server",
"confidence": 95,
"firstSeen": "2024-11-01T00:00:00Z",
"lastSeen": "2024-12-14T10:30:00Z",
"tlpMarking": "amber",
"malwareFamily": "Cobalt Strike",
"threatActor": {
"name": "APT29",
"aliases": ["Cozy Bear", "The Dukes"],
"country": "RU",
"motivation": "espionage"
},
"mitre": {
"tactics": ["Command and Control"],
"techniques": ["T1071.001"]
},
"actions": ["block", "alert", "investigate"],
"sources": ["internal_sandbox", "osint_feed"]
}
```
#### Tutorial 6: Genomic Variant Data for Bioinformatics
Generate VCF-format genetic variant data:
```json
{
"dataType": "genomic_vcf",
"count": 1000,
"seed": "genomics-v1"
}
```
**Sample Output:**
```json
{
"variantId": "VAR_1734012345678",
"chromosome": "chr17",
"position": 7577120,
"rsId": "rs28934578",
"reference": "G",
"alternate": "A",
"quality": 99,
"filter": "PASS",
"genotype": "0/1",
"annotations": {
"gene": "TP53",
"consequence": "missense_variant",
"impact": "HIGH",
"aminoAcidChange": "R248W"
},
"population": {
"gnomAD_AF": 0.00001,
"clinvar": "Pathogenic",
"dbSNP": true
},
"clinical": {
"significance": "pathogenic",
"disease": "Li-Fraumeni syndrome",
"inheritance": "AD"
}
}
```
***
### Memory Session Persistence
v3.0 introduces cross-session memory for data accumulation and sharing between actors:
```json
{
"dataType": "bloomberg",
"count": 1000,
"memorySessionEnabled": true,
"memorySessionId": "financial-data-2024",
"appendToSession": true
}
```
**Benefits:**
- Accumulate data across multiple runs
- Share data between Agentic Synth and AI Memory Engine
- Build persistent datasets over time
- Enable cross-actor workflows
***
### Self-Learning (SONA)
The Self-Optimizing Neural Architecture learns patterns from generated data:
```json
{
"dataType": "bloomberg",
"count": 1000,
"sonaEnabled": true,
"ewcLambda": 2000,
"patternThreshold": 0.7
}
```
| Tier | What It Learns | Example |
|------|----------------|---------|
| **Instant** | Real-time patterns | "Tech stocks correlate with NASDAQ" |
| **Background** | Batch patterns | "Q4 retail volume increases 40%" |
| **Deep** | Cross-session | "Pharma P/E ratios range 15-25" |
#### Deep Training & Optimization
For production workloads, use swarm-orchestrated deep training to maximize pattern learning:
```json
{
"dataType": "bloomberg",
"count": 1000,
"sonaEnabled": true,
"ewcLambda": 2000,
"patternThreshold": 0.7,
"seed": "deep-training-financial-v1"
}
```
##### Optimization Strategies
| Strategy | Description | Best For | EWC Lambda |
|----------|-------------|----------|------------|
| **Rapid Learning** | Low protection, fast adaptation | New data types, exploration | 500-1000 |
| **Balanced** | Moderate protection, steady learning | General production use | 2000 |
| **Conservative** | High protection, stable patterns | Critical financial data | 5000+ |
| **Deep Training** | Extended runs with cross-session memory | Enterprise pattern libraries | 2000 + memory persistence |
##### Concurrent Training Results
| Configuration | Runs | Records | Patterns | Duration | Records/sec |
|---------------|------|---------|----------|----------|-------------|
| Single data type | 10 | 1,000 | ~100 | 12s | 83 |
| 5 types parallel | 50 | 5,000 | ~500 | 15s | 333 |
| 20 types parallel | 200 | 20,000 | ~2,000 | 45s | 444 |
| Full swarm (37 types) | 370 | 37,000 | ~3,700 | 90s | 411 |
##### Pattern Learning by Data Type
| Category | Data Types | Patterns/1K Records | Learning Focus |
|----------|------------|---------------------|----------------|
| **Financial** | bloomberg, factset, lseg | 150-200 | Price correlations, sector patterns |
| **Biosignal** | eeg, cgm, fmri | 100-150 | Waveform characteristics, temporal patterns |
| **Security** | siem, threat\_intel | 120-180 | Attack signatures, IOC relationships |
| **Industrial** | scada, lidar, canbus | 80-120 | Sensor correlations, anomaly patterns |
| **Scientific** | genomic\_vcf, protein\_pdb | 90-140 | Sequence patterns, structural motifs |
##### Swarm Training Command
Run deep training across all 37 data types with concurrent execution:
```bash
## Using Apify CLI with parallel execution
for type in bloomberg eeg siem lidar genomic_vcf; do
apify call ruv/ai-synthetic-data-generator -s \
--input='{"dataType":"'$type'","count":100,"sonaEnabled":true,"ewcLambda":2000}' &
done
wait
```
##### Training Script (Node.js)
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const DATA_TYPES = ['bloomberg', 'eeg', 'siem', 'lidar', 'genomic_vcf'];
// Run concurrent training batches
const results = await Promise.all(
DATA_TYPES.map(type =>
client.actor('ruv/ai-synthetic-data-generator').call({
dataType: type,
count: 100,
sonaEnabled: true,
ewcLambda: 2000
})
)
);
```
#### SONA Learning Benchmark Results
Comprehensive benchmarks measuring SONA's learning capabilities across multiple dimensions:
##### Quantitative Metrics
| Metric | Value | Description |
|--------|-------|-------------|
| **Generation Speed** | 232K records/sec | Peak throughput on Rust/WASM engine |
| **Pattern Detection Rate** | 10-20% | Patterns extracted per 1K records |
| **Learning Convergence** | 3-5 iterations | Iterations to stable pattern set |
| **Memory Retention** | 85-95% | Cross-session pattern preservation |
| **Cross-Domain Transfer** | 60-80% | Pattern applicability across types |
##### EWC Lambda Performance Matrix
| Lambda | Learning Speed | Memory Retention | Stability | Use Case |
|--------|---------------|------------------|-----------|----------|
| 500 | Very Fast | Low (40%) | Volatile | Rapid prototyping |
| 1000 | Fast | Medium (65%) | Moderate | Exploration |
| 2000 | Balanced | High (85%) | Stable | Production |
| 5000 | Slow | Very High (95%) | Very Stable | Critical data |
##### Data Type Learning Profiles
| Category | Types | Pattern Complexity | Learning Rate | Quality Score |
|----------|-------|-------------------|---------------|---------------|
| **Core Web** | 10 | Low-Medium | Fast (1-2 iter) | 90-95% |
| **Financial** | 6 | High | Medium (3-4 iter) | 85-92% |
| **Biosignal** | 3 | Very High | Slow (4-5 iter) | 82-88% |
| **Security** | 3 | High | Medium (3-4 iter) | 85-90% |
| **Industrial** | 3 | Medium-High | Medium (3 iter) | 87-92% |
| **Scientific** | 5 | Very High | Slow (4-5 iter) | 80-88% |
| **Exotic** | 4 | Very High | Slow (5 iter) | 78-85% |
##### Swarm Training Performance
| Topology | Agents | Throughput | Efficiency | Best For |
|----------|--------|------------|------------|----------|
| Sequential | 1 | 30 rec/s | 100% (baseline) | Small batches |
| Parallel (5) | 5 | 140 rec/s | 93% | Standard workloads |
| Parallel (10) | 10 | 260 rec/s | 87% | Large training |
| Parallel (20) | 20 | 440 rec/s | 73% | Deep training |
| Full Swarm (37) | 37 | 720 rec/s | 65% | Comprehensive |
##### Qualitative Learning Capabilities
**Pattern Recognition:**
- Price/value distributions by category
- Temporal correlations in time-series
- Hierarchical relationships in nested data
- Statistical distributions per field type
**Memory Features:**
- EWC++ (Elastic Weight Consolidation) prevents catastrophic forgetting
- Cross-session pattern persistence via Apify KeyValueStore
- Data-type specific pattern libraries
- Trajectory tracking for reward-based learning
**Adaptation Capabilities:**
- Real-time pattern adjustment during generation
- Domain transfer between similar data types
- Quality improvement over successive runs
- Anomaly detection for edge cases
##### Benchmark Methodology
Tests performed on Apify cloud infrastructure:
- **Hardware**: 4GB RAM containers
- **Build**: v3.0.4 with SONA enabled
- **Configuration**: EWC Lambda 2000, Pattern Threshold 0.7
- **Dataset**: 1,000 records per data type, 20 concurrent runs
- **Measurement**: Duration, patterns extracted, quality scores
***
### Performance
#### Benchmark Results (Rust/WASM Engine)
| Records | Time | Records/sec | Use Case |
|---------|------|-------------|----------|
| 100 | 1ms | 100,000 | Unit tests |
| 1,000 | 7ms | 142,857 | Integration tests |
| 10,000 | 53ms | 188,679 | Stress tests |
| 50,000 | 215ms | 232,558 | Load tests |
#### By Data Type Complexity
| Category | Example Type | 1K Records | Complexity |
|----------|--------------|------------|------------|
| Core | ecommerce | 7ms | Low |
| Premium | bloomberg | 15ms | High |
| Biosignal | eeg | 25ms | Very High |
| Scientific | lidar | 30ms | Very High |
***
### API Integration
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient("your-api-token")
run = client.actor("ruv/ai-synthetic-data-generator").call(run_input={
"dataType": "bloomberg",
"count": 1000,
"sonaEnabled": True
})
data = client.dataset(run["defaultDatasetId"]).list_items().items
```
#### JavaScript
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'your-api-token' });
const run = await client.actor('ruv/ai-synthetic-data-generator').call({
dataType: 'siem',
count: 500,
sonaEnabled: true
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```
#### cURL
```bash
curl -X POST "https://api.apify.com/v2/acts/ruv~ai-synthetic-data-generator/runs?token=$APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{"dataType": "threat_intel", "count": 500}'
```
***
### Pricing
#### Core Data Types
| Event | Price | Description |
|-------|-------|-------------|
| E-commerce Record | $0.001 | Products, reviews |
| Social Media Post | $0.001 | Posts, engagement |
| Job/News/Real Estate | $0.001 | Listings |
#### Premium Data Types
| Event | Price | Description |
|-------|-------|-------------|
| Bloomberg Record | $0.005 | Full terminal data |
| ZoomInfo/FactSet/LSEG | $0.005 | Enterprise financial |
| SIEM/Threat Intel | $0.003 | Security data |
| EEG/CGM Biosignal | $0.003 | Medical streams |
| LiDAR/Satellite | $0.004 | Scientific data |
**Example Costs:**
- 1,000 Bloomberg records: ~$5.00 (vs $24K/year real Bloomberg)
- 500 SIEM events: ~$1.50 (vs $50K/year SIEM platform)
- 1,000 EEG epochs: ~$3.00 (vs $50K research equipment)
***
### Links
- [Agentic Synth on Apify](https://apify.com/ruv/ai-synthetic-data-generator)
- [AI Memory Engine](https://apify.com/ruv/ai-memory-engine) - Companion actor for persistent AI memory
- [GitHub Repository](https://github.com/ruvnet/ruvector)
- [Report Issues](https://github.com/ruvnet/ruvector/issues)
***
**Built with [RuVector](https://github.com/ruvnet/ruvector).** Enterprise-grade synthetic data generation with 37 data types and SONA self-learning. Pairs with [AI Memory Engine](https://apify.com/ruv/ai-memory-engine) for complete AI data solutions.
# Actor input Schema
## `mode` (type: `string`):
Operation mode: generate synthetic data or integrate with other Apify actors
## `dataType` (type: `string`):
What type of website or API do you want to simulate?
## `count` (type: `integer`):
How many records to generate (1-10,000). Start small to test, then scale up.
## `schema` (type: `object`):
Define your own data structure for 'structured' type. Example: {"url": "string (url)", "title": "string", "price": "number (10-500)"}
## `apiEndpoint` (type: `string`):
Base endpoint path for API simulation. Example: /api/products
## `eventTypes` (type: `array`):
Types of web events to generate
## `timeSeriesConfig` (type: `object`):
Settings for time-series data (prices, metrics, etc.)
## `integrateActorId` (type: `string`):
Actor ID to pull data from. 21 actors supported. Used in 'integrate' mode.
## `integrateRunId` (type: `string`):
Specific run ID to pull data from, or 'latest' for most recent run
## `integrateDatasetId` (type: `string`):
Direct dataset ID to pull data from (alternative to Run ID)
## `memorizeFields` (type: `array`):
Which fields to extract for RAG/memory. Leave empty for defaults.
## `useTemplate` (type: `string`):
Pre-built template for common use cases. 12 templates available. Used in 'template' mode.
## `generateEmbeddings` (type: `boolean`):
Generate vector embeddings for all output records (useful for RAG systems)
## `useOnnxEmbeddings` (type: `boolean`):
Use real semantic embeddings via ONNX (slower but more accurate) vs random vectors (fast for testing)
## `embeddingModel` (type: `string`):
Choose embedding model. Smaller models are faster, larger models are more accurate.
## `embeddingDimensions` (type: `integer`):
Vector size for embeddings. 384 (fast), 768 (accurate), 1536 (OpenAI compatible)
## `provider` (type: `string`):
AI provider for enhanced generation. DeepSeek via OpenRouter is default (low cost). Works great without AI too!
## `model` (type: `string`):
AI model to use. DeepSeek is extremely low cost ($0.14/1M input, $0.28/1M output).
## `openrouterApiKey` (type: `string`):
Get your key at https://openrouter.ai/keys - Access DeepSeek, GPT-4, Claude, Llama via single API
## `geminiApiKey` (type: `string`):
Get your key at https://aistudio.google.com/apikey - Free tier available
## `anthropicApiKey` (type: `string`):
Get your key at https://console.anthropic.com - Direct Claude API access
## `quality` (type: `number`):
Quality level (0.1-1.0). Higher = more realistic but uses more AI tokens.
## `sonaEnabled` (type: `boolean`):
Enable TRM/SONA self-learning for intelligent pattern recognition in data generation. Learns from generation patterns to improve data quality.
## `ewcLambda` (type: `number`):
Elastic Weight Consolidation strength for pattern preservation. Higher values maintain more learned patterns across generations.
## `patternThreshold` (type: `number`):
Minimum confidence threshold for pattern recognition in data generation (0-1)
## `sonaLearningTiers` (type: `array`):
SONA learning tiers: instant (real-time), background (async optimization), deep (comprehensive analysis)
## `simulationMode` (type: `boolean`):
Enable simulation mode for testing scrapers that poll for updates. Data is pushed in batches with delays.
## `batchSize` (type: `integer`):
Number of records per batch in simulation mode
## `delayBetweenBatches` (type: `integer`):
Milliseconds to wait between batches in simulation mode. Use 1000 for 1 second delays.
## `seed` (type: `string`):
Set a seed for reproducible results. Same seed = same data every time.
## `outputFormat` (type: `string`):
Format for output data
## `webhookUrl` (type: `string`):
URL to POST results to when generation completes (for async workflows)
## `crunchbaseCompanies` (type: `array`):
Specific company names to research. Leave empty to auto-generate based on industry.
## `crunchbaseIndustry` (type: `string`):
Filter companies by industry (e.g., 'fintech', 'healthcare', 'AI/ML'). Leave empty for all industries.
## `memorySessionEnabled` (type: `boolean`):
Save generated data to a persistent memory session. Data persists across runs and can be shared with AI Memory Engine.
## `memorySessionId` (type: `string`):
Unique session identifier. Use the same ID across runs to accumulate data. Can be accessed by AI Memory Engine.
## `appendToSession` (type: `boolean`):
If enabled, new data is added to existing session. If disabled, session is replaced.
## Actor input object example
```json
{
"mode": "generate",
"dataType": "ecommerce",
"count": 100,
"schema": {
"url": "string (url)",
"title": "string",
"price": "number (10-500)",
"rating": "number (1-5)",
"inStock": "boolean",
"category": "string (Electronics, Clothing, Home, Sports)"
},
"apiEndpoint": "/api/products",
"eventTypes": [
"page_view",
"click",
"scroll",
"form_submit",
"api_call"
],
"timeSeriesConfig": {
"interval": "1h",
"trend": "upward",
"seasonality": true,
"noise": 0.1,
"startDate": "2024-01-01"
},
"integrateRunId": "latest",
"memorizeFields": [],
"generateEmbeddings": false,
"useOnnxEmbeddings": true,
"embeddingModel": "all-MiniLM-L6-v2",
"embeddingDimensions": 384,
"provider": "none",
"model": "deepseek/deepseek-chat",
"quality": 0.8,
"sonaEnabled": true,
"ewcLambda": 2000,
"patternThreshold": 0.7,
"sonaLearningTiers": [
"instant",
"background"
],
"simulationMode": false,
"batchSize": 100,
"delayBetweenBatches": 0,
"outputFormat": "json",
"crunchbaseCompanies": [],
"memorySessionEnabled": false,
"appendToSession": true
}
```
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"schema": {
"url": "string (url)",
"title": "string",
"price": "number (10-500)",
"rating": "number (1-5)",
"inStock": "boolean",
"category": "string (Electronics, Clothing, Home, Sports)"
},
"eventTypes": [
"page_view",
"click",
"scroll",
"form_submit",
"api_call"
],
"timeSeriesConfig": {
"interval": "1h",
"trend": "upward",
"seasonality": true,
"noise": 0.1,
"startDate": "2024-01-01"
},
"memorizeFields": [],
"crunchbaseCompanies": []
};
// Run the Actor and wait for it to finish
const run = await client.actor("ruv/ai-synthetic-data-generator").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"schema": {
"url": "string (url)",
"title": "string",
"price": "number (10-500)",
"rating": "number (1-5)",
"inStock": "boolean",
"category": "string (Electronics, Clothing, Home, Sports)",
},
"eventTypes": [
"page_view",
"click",
"scroll",
"form_submit",
"api_call",
],
"timeSeriesConfig": {
"interval": "1h",
"trend": "upward",
"seasonality": True,
"noise": 0.1,
"startDate": "2024-01-01",
},
"memorizeFields": [],
"crunchbaseCompanies": [],
}
# Run the Actor and wait for it to finish
run = client.actor("ruv/ai-synthetic-data-generator").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"schema": {
"url": "string (url)",
"title": "string",
"price": "number (10-500)",
"rating": "number (1-5)",
"inStock": "boolean",
"category": "string (Electronics, Clothing, Home, Sports)"
},
"eventTypes": [
"page_view",
"click",
"scroll",
"form_submit",
"api_call"
],
"timeSeriesConfig": {
"interval": "1h",
"trend": "upward",
"seasonality": true,
"noise": 0.1,
"startDate": "2024-01-01"
},
"memorizeFields": [],
"crunchbaseCompanies": []
}' |
apify call ruv/ai-synthetic-data-generator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,ruv/ai-synthetic-data-generator"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/9r7VfVvLNrr9Gm48u/builds/NhFpT4KL2tq3gbN4g/openapi.json