Struct KhiveConfig 

pub struct KhiveConfig {
    pub engines: Vec<EngineConfig>,
    pub actor: ActorConfig,
}

Top-level khive configuration loaded from khive.toml or config.toml.

Sections consumed today:

• [[engines]]: embedding engine declarations
• [actor]: default namespace / identity (OSS actor model)

Unknown keys are silently ignored by serde — forward-compatible.

Fields

engines: Vec<EngineConfig>

Embedding engine declarations.

actor: ActorConfig

Default actor (namespace) for this khive instance.

When present, actor.id becomes the default_namespace used by the runtime when no per-operation namespace argument is supplied. OSS model: no enforcement — any operation may still pass namespace= to use a different namespace. Cloud model derives namespace from an authenticated token and ignores this field.

Implementations

impl KhiveConfig

pub fn load(path: Option<&Path>) -> Result<Option<Self>, ConfigError>

Load and validate a KhiveConfig from an explicit path.

Search order:

1. path argument (explicit override — e.g. from --config / KHIVE_CONFIG)
2. ./.khive/config.toml (project-local config, relative to the MCP server cwd)

The project-local default collocates config with the khive-test.db that already lives under .khive/ in each project directory. ~/.khive/config.toml is searched by KhiveConfig::load_with_home_fallback when the project-local file is absent.

If the resolved file does not exist, returns Ok(None). A missing config is not an error — callers fall back to the env-var path.

If the file exists but cannot be parsed, returns a ConfigError. After parsing, validate() runs and any logical errors are returned.

pub fn load_with_home_fallback( path: Option<&Path>, ) -> Result<Option<Self>, ConfigError>

Load config with the full resolution order:

1. Explicit path (from --config / KHIVE_CONFIG)
2. ./khive.toml (project-local, project root)
3. ./.khive/config.toml (project-local, hidden dir)
4. ~/.khive/config.toml (user-global)

Returns the first file found, or Ok(None) when none exist. Parse errors are propagated immediately — a malformed config is always an error regardless of which tier it came from.

pub fn validate(&self) -> Result<(), ConfigError>

Validate the parsed config for logical consistency.

Checks:

• Exactly one engine has default = true (when the list is non-empty).
• Engine names are unique.
• fusion_weight, when present, is > 0.

Model name validity is checked lazily at runtime (the config loader does not import lattice_embed directly to keep the dep surface minimal).

pub fn default_engine(&self) -> Option<&EngineConfig>

Return the engine flagged default = true, or None if the list is empty.

Trait Implementations

impl Clone for KhiveConfig

fn clone(&self) -> KhiveConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KhiveConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for KhiveConfig

fn default() -> KhiveConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KhiveConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.