Skip to content

EvoSpikeNet SDK changelog

[!NOTE] For the latest implementation status, please refer to Functional Implementation Status (Remaining Functionality).

[2.3.1] - 2026-04-20

📘 Documentation update (Distributed ASR/Whisper integration)

  • Added operation notes for ASR switching in a distributed environment (VIDEO_ANALYSIS_ASR_BACKEND) and Whisper-related environment variables to SDK_API_REFERENCE.md.
  • Added new sample distributed_video_asr_demo.py to SDK_DOCUMENTATION_INDEX.md
  • Added model-server (optional) and Whisper enablement steps to distributed node configuration in Docs/BUILD_GUIDE.md

🧪 Add sample

  • Docs/sdk/distributed_video_asr_demo.py
  • Health check on multiple nodes
  • Confirm distributed simulation operation using submit_prompt() / poll_for_result()
  • Verification with audio input by specifying --audio-path

⚠️ API Compatibility

  • No SDK public method signature changes (only server-side configuration changes).

[2.3.0] - 2026-03-19

🧬 Phase E-3 Connectome production/automatic synchronization

sync_connectome.py — Automatic sync pipeline (E-3-1)

  • apply_delta(base_path, delta_path, result_path): Apply differential JSON (added/removed synapse list) to existing NPZ and generate new NPZ with atomic write
  • apply_delta_with_validation(base_path, delta_path, result_path, *, rollback_dir, ei_ratio_range): In addition to apply_delta, validate the E/I ratio after application based on cell_types. If out of range, create a backup in rollback_dir and raise ConnectomeSyncValidationError
  • fetch_cave_synapses_with_retry(url, params, max_retries, backoff_factor): HTTP 429 CAVE API synapse fetch with exponential backoff retries
  • fetch_delta_from_cave(config_path, cache_path, cave_url, ...): Get differential data from CAVE API and save it in cache
  • sync_connectome(config_path, cache_path, output_path, *, dry_run, ...): Full sync orchestrator. returns status: "success" | "dry_run" | "no_update"
  • ConnectomeSyncValidationError: Exception class when E/I ratio validation fails
  • CLI: python scripts/sync_connectome.py --cache X.npz --output Y.npz [--dry-run]

brain_routing.py — HCP Latency Aware Zenoh Routing (E-3-3)

  • compute_delay_matrix(manifest, config_path): Generate inter-node delay matrix {src: {dst: ms}} from HCP measured values and hcp_delays section of connectome_config.yaml (clamped to 0.5–20.0 ms)
  • optimize_routing_delays(manifest, delay_matrix): Give each edge a priority score (0 → 1) where the smaller the delay, the higher the priority, and return the routing_edges list sorted in descending order.
  • build_hcp_routing_table(config_path): Integrate build_manifest() → compute_delay_matrix() → optimize_routing_delays() and return {delay_matrix, routing_plan, zenoh_topics}
  • HCPDelayRouter(session, config_path): Graceful degradation implementation that works even when session is None
  • load_routing_table(): Load the routing table into memory
  • apply_hcp_delays(node_id, data): Applies delay profile to data payload
  • publish_delays(node_id): Publish to Zenoh topic brain_routing/delays/{node_id}
  • publish_all(): Publish all nodes at once
  • Zenoh Topic: brain_routing/delays/{node_id}

auto_node_mapper.py — Auto Node Mapper CLI

  • map_connectome(input_path, output_dir, config_path, *, dry_run, seed): Divide and save connectome JSON/NPZ into NPZ for each node and return MappingResult
  • stratified_sample: Random sampling with E/I ratio maintained (F-1 compliant)
  • spectral_coarsen: Spectral degeneracy (F-2 compliant)
  • Output: {output_dir}/{node_type}.npz + node_manifest.yaml
  • generate_manifest(output_dir, config_path): Scan existing NPZ and regenerate node_manifest.yaml
  • MappingResult / NodeMappingEntry: Mapping result data class (to_dict() support)
  • node_manifest.yaml Schema: {schema_version: "1.0", generated_at, base_dataset, nodes: {node_type: {...}}}
  • CLI: python scripts/auto_node_mapper.py --input X.json --output-dir Y/ [--dry-run] [--seed 42]

evospikenet/evolution_engine.py — Gene E/I validation hook (E-3-2)

  • Added connectome gene E/I ratio repair logic to _validate_genome(): If the E/I ratio of a gene with gene_type == "connectome" is outside the [3.5, 5.0] range, inhibitory_count is automatically repaired to E/I = 4.25.

evospikenet/__init__.py — E-3 public symbol added

  • Added HCPDelayRouter, compute_delay_matrix, optimize_routing_delays, build_hcp_routing_table to public export from brain_routing module.

🧪 Add test

  • tests/e2e/test_connectome_e2e.py: E-3-4 Whole Brain E2E Validation (7 classes 27 tests)
  • tests/test_auto_node_mapper.py: Auto Node Mapper unit test (10 tests)
  • tests/test_sync_connectome_integration.py: Differential synchronization/rollback/429 retry integration test (6 tests)
  • Regression test fix: Fixed duplicate edge generation bug in _make_celegans_mini_json() (resolved mismatch between adj.nnz and delays.shape)

⚠️ Changes

  • Fixed datetime.datetime.utcnow() → datetime.datetime.now(datetime.timezone.utc) (resolved Python 3.12 deprecation warning)

[2.2.0] - 2026-03-11

🐛 Bug fixes

advanced_mutations.py — Structural mutation engine consistency fixes

  • genome.copy() → copy.deepcopy(genome): Fixed a bug where apply_mutations() failed with AttributeError every time because .copy() method did not exist in EvoGenome.
  • chromosome.network_topology → chromosome.topology: Corrected all 15 locations for correct attribute names in the Chromosome data class (including ConnectionImportanceAnalyzer)
  • Chromosome constructor argument correction: Corrected non-existent arguments chromosome_id and network_topology used in _duplicate_module / _fuse_modules to module_type, topology, energy_allocation
  • import copy added: Added because the module import required to use copy.deepcopy() was missing.

genome_pool.py — MutationEvent structure modification

  • MutationEvent constructor argument fix: Fixed a bug where non-existent fields mutation_type and parameters_changed were used in _mutate_genome(). Changed to correct generation, description fields

🚀 New features

GenomePool — generation automatic snapshot

  • snapshot_manager parameter added: SnapshotManager can now be injected with GenomePool.__init__(snapshot_manager: Optional[SnapshotManager] = None)
  • **Automatic snapshot after evolve_generation()**: Automatically callsnapshot_manager.create_snapshot("post_generation_{N}")` after generation update. In case of failure, continue with only warning log

MutationEngine — AdvancedMutationEngine pipeline integration

  • advanced_engine parameter added: Optional integration of advanced mutation engine with MutationEngine.__init__(advanced_engine: Optional[AdvancedMutationEngine] = None)
  • mutate_genome() post-step: Call advanced_engine.apply_mutations(mutated) after completing the basic mutation to apply 10 types of structural mutations (layer addition/deletion, skip connection, pruning, etc.)

FitnessEvaluator._evaluate_robustness() — Implementation replacement

  • Previous state: Placeholder returning fixed value {noise_resistance: 0.7, failure_tolerance: 0.6, stability: 0.8}
  • New implementation (with brain): Output stability measurement using Gaussian noise injection (σ=0.2) + Fault tolerance measurement with 10% masking of middle layer weights
  • New implementation (without brain): Structural proxy estimation by number of skip connections, number of recursive connections, and layer depth

rollback.py — SnapshotManager integration

  • rollback_to_snapshot(snapshot_id, manager, target_path) Added new function: Pulls metadata by snapshot ID from SnapshotManager and delegates to existing rollback_version(). Avoid circular imports with TYPE_CHECKING guard

📚 Documentation

  • SDK_API_REFERENCE.md: Added L5 self-evolution/self-healing API section
  • ADVANCED_EVOLUTION_PHASE5_6.md: Updated integration code example to implemented API.

[2.1.0] - 2026-01-23

🚀 New features added

AEG-Comm communication optimization integration

  • AEG-Comm communication control: Intelligent communication gating with 3-layer safety architecture
  • Communication reduction API: get_communication_stats(), set_aeg_comm_config() methods added
  • Distributed brain optimization: 85-93% reduction in communication efficiency in distributed simulations
  • Security Enhancements: Spike encryption and error recovery features

Distributed brain simulation extension

  • AEG-Comm settings: Communication optimization parameters in distributed brain node settings
  • Communication statistics monitoring: Real-time communication quality and reduction rate monitoring
  • Zenoh integration enhancements: Error recovery and automatic reconnection features

📊 Performance improvement

  • 84% reduction in communication delay in distributed brain simulation
  • 3x longer battery life
  • Communication volume reduced by 93%

[2.0.0] - 2026-01-15

🎉 Major Release

Completely renewed version of EvoSpikeNet SDK. Integrates advanced features of Plan F Phase 5-6 to provide full support for distributed brain simulation.

✨ New features

Core enhancements

  • 🔄 Latency monitoring system: get_latency_stats(), check_latency_target()
  • 💾 Snapshot management: save/restore/verify/clean up system state
  • 📊 Scalability Test: Node Scalability and Stress Test
  • 🔧 Hardware optimization: Model optimization and benchmarking features
  • 🛡️ High Availability Monitoring: Health checks, statistics, alerts, maintenance
  • 🌐 Asynchronous Zenoh Communication: Real-time distributed communication protocol
  • ⚖️ Distributed consensus: consensus decision and node state management

Improved developer experience

  • 🔒 Fully type safe: Comprehensive type hinting and mypy support
  • ⚡ Asynchronous support: Asynchronous processing with async/await
  • 📚 Jupyter integration enhancements: Rich display and magic commands
  • 🧪 Test coverage 95%: Comprehensive unit and integration testing
  • 📖 Complete documentation: API reference, tutorial, developer guide

🔄 Changes

API changes

  • Method extension of EvoSpikeNetAPIClient class (25+ new endpoints)
  • Added asynchronous methods (generate_async(), submit_prompt_async())
  • Introduction of WebSocket client (WebSocketClient class)
  • Enhancements to Jupyter integration class (JupyterAPIClient)

Internal improvements

  • Enhanced type safety for requests/responses
  • Unified error handling (EvoSpikeNetAPIError)
  • Added statistics collection function
  • Optimized connection pooling

📚 Documentation

💡 Sample code

Added new sample code: - advanced_features_demo.py: Comprehensive demo of advanced features - async_operations_demo.py: Demonstration of asynchronous processing - Improvements and extensions to existing samples

[1.5.0] - 2025-12-21

🚀 Added features

  • Multimodal processing: Supports image and audio input
  • Batch processing: Process multiple prompts at once
  • Artifact management: Manage models, logs, and settings
  • Remote log acquisition: Remote node log collection via SSH
  • Statistics Monitoring: Collect client usage statistics

🔧 Improvement

  • Enhanced error handling
  • Implementation of retry mechanism
  • Connection timeout optimization
  • Reduced memory usage

[1.0.0] - 2025-10-15

🎯 First release

  • Basic text generation functions
  • Cooperation with distributed brain simulation
  • REST API client implementation
  • Jupyter Notebook integration
  • Basic error handling

Version control policy

Semantic versioning

This project employs semantic versioning:

  • MAJOR: Backwards incompatible change
  • MINOR: New features with backward compatibility
  • PATCH: Backwards compatible bug fixes

Release cycle

  • Major Release: Every six months (on completion of Plan F phase)
  • Minor release: Once a month (when new features are added)
  • Patch Release: As needed (when bugs are fixed)

Support period

  • Latest major version: Fully supported
  • 1 generation previous major version: Security fixes only
  • Before: End of support

Migration Guide

1.x → 2.0

Breaking changes

  1. Constructor change```python # 1.x client = EvoSpikeNetAPIClient("http://localhost:8000")

# 2.0 client = EvoSpikeNetAPIClient(base_url="http://localhost:8000") ```

  1. Method signature change```python # 1.x result = client.generate("prompt", 100)

# 2.0 result = client.generate("prompt", max_length=100) ```

Take advantage of new features

  1. Introducing asynchronous processing```python # Synchronous processing result = client.generate("prompt")

# Asynchronous processing (new) result = await client.generate_async("prompt") ```

  1. Using advanced features```python # Snapshot management (new) snapshot = client.create_snapshot("backup")

# Zenoh communication (new) client.connect_zenoh("node_id") ```

  1. Update dependencies: pip install -e . --upgrade
  2. Code review: Check constructors and method calls
  3. Test execution: Check compatibility of existing tests
  4. Introducing new features: Introducing advanced features in stages
  5. Performance optimization: Leverage asynchronous processing

Future plans

2.1.0 (2026 Q2 planned)

  • Streaming response: Real-time text generation
  • Custom Model: Support for user-defined models
  • Enhanced Zenoh: Advanced communication patterns
  • Performance optimization: Further reduction of memory usage

2.2.0 (planned for 2026 Q3)

  • Distributed Learning: Federated Learning Support
  • Model Marketplace: Shared model management
  • Advanced Monitoring: Detailed telemetry
  • Plugin system: Support for custom extensions

3.0.0 (planned for 2026 Q4)

  • Quantum Ready: Quantum Computing Integration
  • Multi-cloud: Supports multiple cloud providers
  • Autonomous optimization: Automatic optimization by AI
  • Edge Computing: Supports IoT devices

Contributor

  • Masahiro Aoki: Project lead, SDK architecture design
  • EvoSpikeNet Team: Distributed Brain Simulation Integration
  • Community Contributors: Tests, documentation, sample code

Feedback

If you have any questions or feedback about this changelog or the SDK, please send them to GitHub Issues or Discussions. /Users/maoki/Documents/GitHub/EvoSpikeNet/docs/SDK_CHANGELOG.md