FEAGI Service Layer

The stable application boundary for FEAGI - defines transport-agnostic service interfaces that can be used by any adapter (REST API, ZMQ, embedded).

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    TRANSPORT ADAPTERS                            │
│  Axum/REST, ZMQ Control, Embedded I2C, etc.                     │
└────────────────────────────┬────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│              SERVICE LAYER (This Crate)                          │
│  • NeuronService      - Neuron CRUD operations                  │
│  • GenomeService      - Genome load/save                        │
│  • ConnectomeService  - Cortical area & brain region management │
│  • AnalyticsService   - Statistics & system health              │
└────────────────────────────┬────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│                   DOMAIN LAYER                                   │
│  feagi-bdu, feagi-evo, feagi-burst-engine, feagi-types          │
└─────────────────────────────────────────────────────────────────┘

Design Principles

1. Transport-Agnostic: Services know nothing about HTTP, ZMQ, or I2C
2. Stable Contracts: Trait interfaces don't change when backend changes
3. Async by Default: All services are async (can be compiled out for embedded)
4. Error Translation: Backend errors are translated to transport-agnostic ServiceError
5. DTO-Based: All parameters and returns use transport-agnostic DTOs

Usage

For Adapter Implementers

Adapters depend on service traits, not implementations:

use feagi_services::{NeuronService, ServiceResult, CreateNeuronParams};

async fn handle_http_request(
service: &dyn NeuronService,
req: HttpRequest
) -> HttpResponse {
// 1. Parse HTTP request to DTO
let params = CreateNeuronParams { ... };

// 2. Call service (transport-agnostic)
let result = service.create_neuron(params).await?;

// 3. Convert DTO to HTTP response
HttpResponse::ok(result)
}

For Backend Implementers

Implementations use domain logic (BDU, NPU, Evo):

use feagi_services::{NeuronService, ServiceResult};
use feagi_brain_development::ConnectomeManager;

struct NeuronServiceImpl {
connectome: Arc<ConnectomeManager>,
}

#[async_trait]
impl NeuronService for NeuronServiceImpl {
async fn create_neuron(&self, params: CreateNeuronParams) -> ServiceResult<NeuronInfo> {
// Delegate to domain logic
self.connectome.create_neuron(...)?;
Ok(NeuronInfo { ... })
}
}

Copyright 2025 Neuraville Inc. Licensed under the Apache License, Version 2.0

feagi-services

FEAGI service layer - Stable application boundary for transport adapters.

Overview

Transport-agnostic business logic layer that can be used by:

• REST API (HTTP)
• ZMQ control
• Embedded I2C
• Any custom transport

Provides services for:

• Neuron operations
• Genome management
• Connectome manipulation
• System analytics
• Runtime control

Installation

[dependencies]
feagi-services = "2.0"

Usage

use feagi_services::{NeuronService, GenomeService};

// Implement for your transport
impl NeuronService for MyTransport {
    async fn create_neuron(&self, params: CreateNeuronParams) -> ServiceResult<NeuronInfo> {
        // Business logic here
    }
}

Architecture

Services sit between transport adapters (HTTP/ZMQ/etc.) and domain logic (BDU/NPU/etc.), providing a stable interface that doesn't change when either layer changes.

Part of the FEAGI ecosystem.