Skip to content

BrainAPI is a knowledge graph–powered AI memory layer that transforms unstructured data into structured knowledge, enabling intelligent search, recommendations, and contextual memory for AI agents and applications.

feat(plugins)

Christian542cef174f93
diff --git a/.env.example b/.env.example
index a658f46..ed59576 100644
--- a/.env.example
+++ b/.env.example
@@ -112,4 +112,10 @@ OLLAMA_PORT=11434
# OLLAMA_LLM_LARGE_MODEL="hf.co/MaziyarPanahi/Qwen3-8B-GGUF:Q4_K_M"
# OLLAMA_LLM_SMALL_MODEL="hf.co/MaziyarPanahi/Qwen3-8B-GGUF:Q4_K_M"
OLLAMA_LLM_SMALL_MODEL="hf.co/unsloth/Qwen3-14B-GGUF:Q4_K_M"
-OLLAMA_LLM_LARGE_MODEL="hf.co/unsloth/Qwen3-14B-GGUF:Q4_K_M"
\ No newline at end of file
+OLLAMA_LLM_LARGE_MODEL="hf.co/unsloth/Qwen3-14B-GGUF:Q4_K_M"
+
+# Plugins
+PLUGINS_DIR="plugins"
+PLUGIN_REGISTRY_URL="https://registry.brain-api.dev"
+PLUGIN_PUBLISHER_API_KEY="your-publisher-api-key"
+PLUGIN_PUBLISHER_ID="your-publisher-id"
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index 5934915..bd58b6a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -83,6 +83,9 @@ COPY entrypoint.sh ./
RUN chmod +x /app/entrypoint.sh
+RUN mkdir -p /app/plugins && chown appuser:appuser /app/plugins
+VOLUME ["/app/plugins"]
+
EXPOSE 8000
HEALTHCHECK --interval=30s --timeout=30s --start-period=120s --retries=5 \
diff --git a/bin/brainapi b/bin/brainapi
new file mode 100755
index 0000000..7f62233
--- /dev/null
+++ b/bin/brainapi
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -e
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "$PROJECT_ROOT"
+export PYTHONPATH="$PROJECT_ROOT${PYTHONPATH:+:$PYTHONPATH}"
+exec poetry run python src/core/plugins/cli.py "$@"
diff --git a/entrypoint.sh b/entrypoint.sh
index 4aa4f90..2078175 100644
--- a/entrypoint.sh
+++ b/entrypoint.sh
@@ -5,4 +5,19 @@ if [ -d /app/.cache ]; then
chown -R appuser:appuser /app/.cache 2>/dev/null || true
fi
+mkdir -p /app/plugins
+chown -R appuser:appuser /app/plugins 2>/dev/null || true
+
+if [ -n "$BRAINAPI_PLUGINS" ]; then
+ IFS=',' read -ra PLUGINS <<< "$BRAINAPI_PLUGINS"
+ for plugin_spec in "${PLUGINS[@]}"; do
+ plugin_spec="$(echo "$plugin_spec" | xargs)"
+ name="${plugin_spec%%:*}"
+ version="${plugin_spec##*:}"
+ [ "$name" = "$version" ] && version="latest"
+ echo "[brainapi] Installing plugin: $name v$version"
+ gosu appuser /app/.venv/bin/python -m src.core.plugins.cli install "$name" --version "$version" || echo "[brainapi] WARNING: Failed to install plugin '$name'"
+ done
+fi
+
exec gosu appuser /app/.venv/bin/python "$@"
diff --git a/example-docker-compose.yaml b/example-docker-compose.yaml
index ffc0fca..0f81e06 100644
--- a/example-docker-compose.yaml
+++ b/example-docker-compose.yaml
@@ -1,6 +1,28 @@
version: "3.8"
services:
+ nginx:
+ image: nginx:stable-alpine
+ container_name: brainapi-nginx
+ ports:
+ - "80:80"
+ - "443:443"
+ volumes:
+ - /srv/nginx/conf/nginx.conf:/etc/nginx/nginx.conf:ro
+ - /srv/nginx/conf/conf.d:/etc/nginx/conf.d:ro
+ - /etc/letsencrypt:/etc/letsencrypt:ro
+ - /srv/nginx/logs:/var/log/nginx
+ networks:
+ - appnet
+ restart: unless-stopped
+ depends_on:
+ - redis
+ - mongo
+ - neo4j
+ - milvus
+ mem_limit: 128m
+ cpus: 0.2
+
redis:
image: redis:7-alpine
container_name: brainapi-redis
@@ -11,17 +33,17 @@ services:
command: >
redis-server
--appendonly yes
- --maxmemory 2gb
- --maxmemory-policy volatile-lru
+ --maxmemory 1500mb
+ --maxmemory-policy allkeys-lru
--save 900 1
--save 300 10
--save 60 10000
--tcp-backlog 511
- --timeout 0
+ --timeout 300
networks:
- appnet
restart: unless-stopped
- mem_limit: 512m
+ mem_limit: 2048m
cpus: 0.5
healthcheck:
test: ["CMD", "redis-cli", "ping"]
@@ -41,7 +63,7 @@ services:
- neo4j-plugins:/plugins
- ./src/config/neo4j:/var/lib/neo4j/conf
environment:
- - NEO4J_AUTH=neo4j/${NEO4J_PASSWORD:-your_password}
+ - NEO4J_AUTH=neo4j/your_password
- NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
- NEO4J_PLUGINS=["apoc"]
- NEO4J_server_memory_heap_max__size=2g
@@ -145,8 +167,8 @@ services:
ports:
- "27017:27017"
environment:
- MONGO_INITDB_ROOT_USERNAME: ${MONGO_ROOT_USERNAME:-root}
- MONGO_INITDB_ROOT_PASSWORD: ${MONGO_ROOT_PASSWORD:-password}
+ MONGO_INITDB_ROOT_USERNAME: root
+ MONGO_INITDB_ROOT_PASSWORD: password
volumes:
- mongo-data:/data/db
- mongo-config:/data/configdb
@@ -168,23 +190,40 @@ services:
interval: 10s
timeout: 5s
retries: 5
+
brainapi:
- image: ghcr.io/lumen-labs/brainapi:latest
+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-dev
container_name: brainapi-api
ports:
- "8000:8000"
env_file:
- - .env
- command: >
- -m uvicorn src.services.api.app:app
- --host 0.0.0.0
- --port 8000
- --workers 4
- --timeout-keep-alive 30
- --limit-concurrency 200
- --backlog 2048
- tmpfs:
- - /tmp:size=512M
+ - /root/.env
+ environment:
+ PLUGIN_REGISTRY_URL: ${PLUGIN_REGISTRY_URL:-}
+ PLUGIN_PUBLISHER_ID: ${PLUGIN_PUBLISHER_ID:-}
+ PLUGIN_PUBLISHER_API_KEY: ${PLUGIN_PUBLISHER_API_KEY:-}
+ BRAINAPI_PLUGINS: my-plugin:1.0.0,analytics-plugin
+ volumes:
+ - /root/gcp_credentials.json:/app/gcp_credentials.json
+ - brainapi-plugins:/app/plugins
+ command:
+ [
+ "-m",
+ "uvicorn",
+ "src.services.api.app:app",
+ "--host",
+ "0.0.0.0",
+ "--port",
+ "8000",
+ "--workers",
+ "1",
+ "--timeout-keep-alive",
+ "30",
+ "--limit-concurrency",
+ "200",
+ "--backlog",
+ "2048",
+ ]
depends_on:
redis:
condition: service_healthy
@@ -197,8 +236,8 @@ services:
networks:
- appnet
restart: unless-stopped
- mem_limit: 1024m
- cpus: 0.9
+ mem_limit: 4g
+ cpus: 2
healthcheck:
test:
[
@@ -211,25 +250,32 @@ services:
]
interval: 30s
timeout: 10s
- retries: 3
- start_period: 60s
+ retries: 5
+ start_period: 900s
+ start_interval: 30s
brainapi-worker:
- image: ghcr.io/lumen-labs/brainapi:latest
+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-dev
container_name: brainapi-worker
env_file:
- - .env
+ - /root/.env
environment:
- CELERY_WORKER_CONCURRENCY: ${CELERY_WORKER_CONCURRENCY:-4}
- command: >
- -m celery
- -A src.workers.app:ingestion_app worker
- -Q ingest_data,process_architect_relationships,ingest_structured_data,consolidate_graph
- --loglevel=info
- --prefetch-multiplier=1
- --optimization=fair
- tmpfs:
- - /tmp:size=512M
+ BRAINAPI_PLUGINS: ${BRAINAPI_PLUGINS:-}
+ PLUGIN_REGISTRY_URL: ${PLUGIN_REGISTRY_URL:-}
+ PLUGIN_PUBLISHER_ID: ${PLUGIN_PUBLISHER_ID:-}
+ PLUGIN_PUBLISHER_API_KEY: ${PLUGIN_PUBLISHER_API_KEY:-}
+ volumes:
+ - /root/gcp_credentials.json:/app/gcp_credentials.json
+ - brainapi-plugins:/app/plugins
+ command:
+ [
+ "-m",
+ "celery",
+ "-A",
+ "src.workers.app",
+ "worker",
+ "--loglevel=info",
+ ]
depends_on:
redis:
condition: service_healthy
@@ -242,34 +288,43 @@ services:
networks:
- appnet
restart: unless-stopped
- mem_limit: 1408m
- cpus: 0.9
- deploy:
- resources:
- limits:
- cpus: "0.9"
- memory: 1408m
+ mem_limit: 4g
+ cpus: 2
healthcheck:
- test: ["CMD", "celery", "-A", "src.workers.app:ingestion_app", "inspect", "ping"]
+ test: ["CMD", "celery", "-A", "src.workers.app", "inspect", "ping"]
interval: 30s
- timeout: 5s
- retries: 3
- start_period: 60s
+ timeout: 10s
+ retries: 5
+ start_period: 900s
+ start_interval: 30s
brainapi-mcp:
- image: ghcr.io/lumen-labs/brainapi:latest
+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-dev
container_name: brainapi-mcp
ports:
- "8001:8001"
env_file:
- - .env
- command: >
- -m uvicorn src.services.mcp.app:app
- --host 0.0.0.0
- --port 8001
- --timeout-keep-alive 30
- tmpfs:
- - /tmp:size=512M
+ - /root/.env
+ environment:
+ BRAINAPI_PLUGINS: ${BRAINAPI_PLUGINS:-}
+ PLUGIN_REGISTRY_URL: ${PLUGIN_REGISTRY_URL:-}
+ PLUGIN_PUBLISHER_ID: ${PLUGIN_PUBLISHER_ID:-}
+ PLUGIN_PUBLISHER_API_KEY: ${PLUGIN_PUBLISHER_API_KEY:-}
+ volumes:
+ - /root/gcp_credentials.json:/app/gcp_credentials.json
+ - brainapi-plugins:/app/plugins
+ command:
+ [
+ "-m",
+ "uvicorn",
+ "src.services.mcp.app:app",
+ "--host",
+ "0.0.0.0",
+ "--port",
+ "8001",
+ "--timeout-keep-alive",
+ "30",
+ ]
depends_on:
redis:
condition: service_healthy
@@ -282,10 +337,14 @@ services:
networks:
- appnet
restart: unless-stopped
- mem_limit: 512m
- cpus: 0.5
+ mem_limit: 4g
+ cpus: 2
healthcheck:
- test: ["CMD-SHELL", "code=$(curl -s -o /dev/null -w '%{http_code}' http://localhost:8001/); test \"$code\" = '200' || test \"$code\" = '405'"]
+ test:
+ [
+ "CMD-SHELL",
+ 'code=$(curl -s -o /dev/null -w ''%{http_code}'' http://localhost:8001/); test "$code" = ''200'' || test "$code" = ''405''',
+ ]
interval: 30s
timeout: 10s
retries: 3
@@ -294,26 +353,15 @@ services:
networks:
appnet:
driver: bridge
- ipam:
- config:
- - subnet: 172.20.0.0/16
volumes:
redis-data:
- driver: local
neo4j-data:
- driver: local
neo4j-logs:
- driver: local
neo4j-plugins:
- driver: local
etcd-data:
- driver: local
minio-data:
- driver: local
milvus-data:
- driver: local
mongo-data:
- driver: local
mongo-config:
- driver: local
+ brainapi-plugins:
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 1c1ef2f..7ae9e0e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,6 +80,9 @@ accelerate = ">=1.0.0,<2.0.0"
[tool.pylint.messages_control]
enable = ["abstract-method"]
+[tool.poetry.scripts]
+brainapi = "src.core.plugins.cli:app"
+
[tool.pylint.design]
max-args = 10
max-locals = 15
diff --git a/src/core/agents/architect_agent.py b/src/core/agents/architect_agent.py
index 4abf8fc..562da86 100644
--- a/src/core/agents/architect_agent.py
+++ b/src/core/agents/architect_agent.py
@@ -36,6 +36,7 @@ from src.constants.prompts.architect_agent import (
ARCHITECT_AGENT_CREATE_RELATIONSHIPS_PROMPT,
)
from src.core.agents.core.agent_base import AgentBase
+from src.core.plugins.prompts import prompt_registry
from src.core.agents.scout_agent import ScoutEntity
from src.constants.agents import (
_ArchitectAgentResponse,
@@ -222,18 +223,24 @@ class ArchitectAgent:
system_prompt = ""
if type_ == "single":
- system_prompt = ARCHITECT_AGENT_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "ARCHITECT_AGENT_SYSTEM_PROMPT", ARCHITECT_AGENT_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=(extra_system_prompt if extra_system_prompt else "")
)
elif type_ == "tooler":
if mode == "granular":
- system_prompt = ARCHITECT_AGENT_TOOLER_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "ARCHITECT_AGENT_TOOLER_SYSTEM_PROMPT", ARCHITECT_AGENT_TOOLER_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=(
extra_system_prompt if extra_system_prompt else ""
)
)
if mode == "coarse":
- system_prompt = ARCHITECT_AGENT_TOOLER_COARSE_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "ARCHITECT_AGENT_TOOLER_COARSE_SYSTEM_PROMPT", ARCHITECT_AGENT_TOOLER_COARSE_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=(
extra_system_prompt if extra_system_prompt else ""
)
@@ -335,7 +342,9 @@ class ArchitectAgent:
messages_list.append(
{
"role": "user",
- "content": ARCHITECT_AGENT_CREATE_RELATIONSHIPS_PROMPT.format(
+ "content": prompt_registry.get(
+ "ARCHITECT_AGENT_CREATE_RELATIONSHIPS_PROMPT", ARCHITECT_AGENT_CREATE_RELATIONSHIPS_PROMPT
+ ).format(
text=text,
entities=[entity.model_dump(mode="json") for entity in ent],
previously_created_relationships=(
@@ -624,7 +633,10 @@ class ArchitectAgent:
)
content = ""
if mode == "granular":
- content = ARCHITECT_AGENT_TOOLER_CREATE_RELATIONSHIPS_PROMPT.format(
+ content = prompt_registry.get(
+ "ARCHITECT_AGENT_TOOLER_CREATE_RELATIONSHIPS_PROMPT",
+ ARCHITECT_AGENT_TOOLER_CREATE_RELATIONSHIPS_PROMPT,
+ ).format(
text=text,
targeting=(
f"""
@@ -640,7 +652,10 @@ class ArchitectAgent:
),
)
if mode == "coarse":
- content = ARCHITECT_AGENT_COARSE_TOOLER_CREATE_RELATIONSHIPS_PROMPT.format(
+ content = prompt_registry.get(
+ "ARCHITECT_AGENT_COARSE_TOOLER_CREATE_RELATIONSHIPS_PROMPT",
+ ARCHITECT_AGENT_COARSE_TOOLER_CREATE_RELATIONSHIPS_PROMPT,
+ ).format(
text=text,
targeting=(
f"""
diff --git a/src/core/agents/janitor_agent.py b/src/core/agents/janitor_agent.py
index 0792130..f8bd148 100644
--- a/src/core/agents/janitor_agent.py
+++ b/src/core/agents/janitor_agent.py
@@ -39,6 +39,7 @@ from src.constants.prompts.janitor_agent import (
JANITOR_AGENT_GRAPH_NORMALIZATOR_PROMPT,
JANITOR_AGENT_GRAPH_NORMALIZATOR_SYSTEM_PROMPT,
)
+from src.core.plugins.prompts import prompt_registry
from src.core.agents.architect_agent import (
ArchitectAgentRelationship,
ArchitectAgentNew,
@@ -171,15 +172,21 @@ class JanitorAgent:
"""
system_prompt = None
if type_ == "janitor":
- system_prompt = JANITOR_AGENT_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "JANITOR_AGENT_SYSTEM_PROMPT", JANITOR_AGENT_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
elif type_ == "graph-janitor":
- system_prompt = JANITOR_AGENT_GRAPH_NORMALIZATOR_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "JANITOR_AGENT_GRAPH_NORMALIZATOR_SYSTEM_PROMPT", JANITOR_AGENT_GRAPH_NORMALIZATOR_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else "",
)
elif type_ == "atomic-janitor":
- system_prompt = ATOMIC_JANITOR_AGENT_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "ATOMIC_JANITOR_AGENT_SYSTEM_PROMPT", ATOMIC_JANITOR_AGENT_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
else:
@@ -323,7 +330,9 @@ class JanitorAgent:
messages_list.append(
{
"role": "user",
- "content": JANITOR_AGENT_GRAPH_NORMALIZATOR_PROMPT.format(
+ "content": prompt_registry.get(
+ "JANITOR_AGENT_GRAPH_NORMALIZATOR_PROMPT", JANITOR_AGENT_GRAPH_NORMALIZATOR_PROMPT
+ ).format(
snapshot_json=json.dumps(hops),
units=json.dumps(
strip_properties(
@@ -480,7 +489,9 @@ class JanitorAgent:
messages_list.append(
{
"role": "user",
- "content": JANITOR_AGENT_NORMALIZE_INSERTION_PROMPT.format(
+ "content": prompt_registry.get(
+ "JANITOR_AGENT_NORMALIZE_INSERTION_PROMPT", JANITOR_AGENT_NORMALIZE_INSERTION_PROMPT
+ ).format(
unit_of_work=input_output.model_dump_json(),
text=text,
targeting=(
@@ -648,7 +659,9 @@ class JanitorAgent:
messages_list.append(
{
"role": "user",
- "content": ATOMIC_JANITOR_AGENT_PROMPT.format(
+ "content": prompt_registry.get(
+ "ATOMIC_JANITOR_AGENT_PROMPT", ATOMIC_JANITOR_AGENT_PROMPT
+ ).format(
units_of_work=json.dumps(
strip_properties(
[
diff --git a/src/core/agents/kg_agent.py b/src/core/agents/kg_agent.py
index a0e5949..db28ff6 100644
--- a/src/core/agents/kg_agent.py
+++ b/src/core/agents/kg_agent.py
@@ -38,6 +38,7 @@ from src.constants.prompts.kg_agent import (
KG_AGENT_UPDATE_STRUCTURED_PROMPT,
)
from src.core.agents.core.agent_base import AgentBase
+from src.core.plugins.prompts import prompt_registry
from src.core.agents.tools.kg_agent import (
KGAgentAddTripletsTool,
KGAgentDeleteRelationshipTool,
@@ -179,11 +180,15 @@ class KGAgent:
"""
system_prompt = None
if type_ == "normal":
- system_prompt = KG_AGENT_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "KG_AGENT_SYSTEM_PROMPT", KG_AGENT_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
elif type_ == "graph-consolidator":
- system_prompt = KG_AGENT_GRAPH_CONSOLIDATOR_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "KG_AGENT_GRAPH_CONSOLIDATOR_SYSTEM_PROMPT", KG_AGENT_GRAPH_CONSOLIDATOR_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
@@ -244,7 +249,9 @@ class KGAgent:
"messages": [
{
"role": "user",
- "content": KG_AGENT_UPDATE_PROMPT.format(
+ "content": prompt_registry.get(
+ "KG_AGENT_UPDATE_PROMPT", KG_AGENT_UPDATE_PROMPT
+ ).format(
information=information,
preferred_entities=(
preferred_entities_prompt if preferred_entities else ""
@@ -287,7 +294,9 @@ class KGAgent:
"messages": [
{
"role": "user",
- "content": KG_AGENT_UPDATE_STRUCTURED_PROMPT.format(
+ "content": prompt_registry.get(
+ "KG_AGENT_UPDATE_STRUCTURED_PROMPT", KG_AGENT_UPDATE_STRUCTURED_PROMPT
+ ).format(
textual_data=textual_data,
main_node=main_node,
),
@@ -367,7 +376,9 @@ class KGAgent:
"messages": [
{
"role": "user",
- "content": KG_AGENT_RETRIEVE_NEIGHBORS_PROMPT.format(
+ "content": prompt_registry.get(
+ "KG_AGENT_RETRIEVE_NEIGHBORS_PROMPT", KG_AGENT_RETRIEVE_NEIGHBORS_PROMPT
+ ).format(
main_node=node, looking_for=looking_for_prompt, limit=limit
),
}
@@ -469,7 +480,9 @@ class KGAgent:
"messages": [
{
"role": "user",
- "content": KG_AGENT_GRAPH_CONSOLIDATOR_PROMPT.format(
+ "content": prompt_registry.get(
+ "KG_AGENT_GRAPH_CONSOLIDATOR_PROMPT", KG_AGENT_GRAPH_CONSOLIDATOR_PROMPT
+ ).format(
task=task
),
}
diff --git a/src/core/agents/observations_agent.py b/src/core/agents/observations_agent.py
index 92ba3d3..a53886a 100644
--- a/src/core/agents/observations_agent.py
+++ b/src/core/agents/observations_agent.py
@@ -11,6 +11,7 @@ Modified By: the developer formerly known as Christian Nonis at <alch.infoemail@
from typing import List, Optional
from src.adapters.llm import LLMAdapter
from src.constants.prompts.observations_agent import OBSERVATIONS_AGENT_SYSTEM_PROMPT
+from src.core.plugins.prompts import prompt_registry
from src.utils.serialization.data import str_to_json
@@ -28,7 +29,9 @@ class ObservationsAgent:
"""
return str_to_json(
self.llm_adapter.generate_text(
- OBSERVATIONS_AGENT_SYSTEM_PROMPT.format(
+ prompt_registry.get(
+ "OBSERVATIONS_AGENT_SYSTEM_PROMPT", OBSERVATIONS_AGENT_SYSTEM_PROMPT
+ ).format(
text=text, observate_for=observate_for
)
),
diff --git a/src/core/agents/scout_agent.py b/src/core/agents/scout_agent.py
index 33b3532..0733a22 100644
--- a/src/core/agents/scout_agent.py
+++ b/src/core/agents/scout_agent.py
@@ -35,6 +35,7 @@ from src.constants.prompts.scout_agent import (
SCOUT_AGENT_SYSTEM_PROMPT,
)
from src.core.agents.core.agent_base import AgentBase, parse_structured_from_messages
+from src.core.plugins.prompts import prompt_registry
from src.utils.tokens import token_detail_from_token_counts
@@ -131,11 +132,15 @@ class ScoutAgent:
mode: Literal["granular", "coarse"] = "granular",
):
if mode == "granular":
- system_prompt = SCOUT_AGENT_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "SCOUT_AGENT_SYSTEM_PROMPT", SCOUT_AGENT_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
if mode == "coarse":
- system_prompt = SCOUT_AGENT_COARSE_SYSTEM_PROMPT.format(
+ system_prompt = prompt_registry.get(
+ "SCOUT_AGENT_COARSE_SYSTEM_PROMPT", SCOUT_AGENT_COARSE_SYSTEM_PROMPT
+ ).format(
extra_system_prompt=extra_system_prompt if extra_system_prompt else ""
)
@@ -204,12 +209,16 @@ class ScoutAgent:
else ""
)
if mode == "granular":
- prompt = SCOUT_AGENT_EXTRACT_ENTITIES_PROMPT.format(
+ prompt = prompt_registry.get(
+ "SCOUT_AGENT_EXTRACT_ENTITIES_PROMPT", SCOUT_AGENT_EXTRACT_ENTITIES_PROMPT
+ ).format(
text=text,
targeting=targeting_str,
)
if mode == "coarse":
- prompt = SCOUT_AGENT_COARSE_EXTRACT_ENTITIES_PROMPT.format(
+ prompt = prompt_registry.get(
+ "SCOUT_AGENT_COARSE_EXTRACT_ENTITIES_PROMPT", SCOUT_AGENT_COARSE_EXTRACT_ENTITIES_PROMPT
+ ).format(
text=text,
targeting=targeting_str,
)
diff --git a/src/core/instances.py b/src/core/instances.py
index b1988be..a751a9c 100644
--- a/src/core/instances.py
+++ b/src/core/instances.py
@@ -1,9 +1,72 @@
-"""
-File: /instances.py
-Created Date: Friday November 7th 2025
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Friday November 7th 2025 8:35:34 pm
-Modified By: the developer formerly known as Christian Nonis at <[email protected]>
------
-"""
+from src.adapters.cache import CacheAdapter
+from src.adapters.data import DataAdapter
+from src.adapters.embeddings import EmbeddingsAdapter, VectorStoreAdapter
+from src.adapters.graph import GraphAdapter
+from src.adapters.llm import LLMAdapter
+from src.config import config
+from src.lib.milvus.client import _milvus_client
+from src.lib.mongo.client import _mongo_client
+from src.lib.neo4j.client import _neo4j_client
+from src.lib.redis.client import _redis_client
+
+_MODES = ("local", "remote")
+
+
+def _require_mode():
+ if config.models_mode not in _MODES:
+ raise ValueError(f"Invalid models mode: {config.models_mode}")
+ return config.models_mode == "local"
+
+
+_is_local = _require_mode()
+
+if _is_local:
+ from src.lib.llm.client_ollama import _llm_large_client, _llm_small_client
+
+ _llm_small = LLMAdapter()
+ _llm_small.add_client(_llm_small_client)
+ _llm_large = LLMAdapter()
+ _llm_large.add_client(_llm_large_client)
+else:
+ from src.lib.llm.client_large import _llm_large_client
+ from src.lib.llm.client_small import _llm_small_client
+
+ _llm_small = LLMAdapter()
+ _llm_small.add_client(_llm_small_client)
+ _llm_large = LLMAdapter()
+ _llm_large.add_client(_llm_large_client)
+
+llm_small_adapter = _llm_small
+llm_large_adapter = _llm_large
+
+cache_adapter = CacheAdapter()
+cache_adapter.add_client(_redis_client)
+
+graph_adapter = GraphAdapter()
+graph_adapter.add_client(_neo4j_client)
+
+data_adapter = DataAdapter()
+data_adapter.add_client(_mongo_client)
+
+if _is_local:
+ from src.lib.embeddings.local import _embeddings_local_client
+ from src.lib.embeddings.client_small import _embeddings_small_client
+
+ _embeddings_primary = EmbeddingsAdapter()
+ _embeddings_primary.add_client(_embeddings_local_client)
+ _embeddings_small = EmbeddingsAdapter()
+ _embeddings_small.add_client(_embeddings_small_client)
+else:
+ from src.lib.embeddings.client import _embeddings_client
+ from src.lib.embeddings.client_small import _embeddings_small_client
+
+ _embeddings_primary = EmbeddingsAdapter()
+ _embeddings_primary.add_client(_embeddings_client)
+ _embeddings_small = EmbeddingsAdapter()
+ _embeddings_small.add_client(_embeddings_small_client)
+
+embeddings_adapter = _embeddings_primary
+embeddings_small_adapter = _embeddings_small
+
+vector_store_adapter = VectorStoreAdapter()
+vector_store_adapter.add_client(_milvus_client)
diff --git a/src/core/layers/graph_consolidation/graph_consolidation.py b/src/core/layers/graph_consolidation/graph_consolidation.py
index c969728..bc95e68 100644
--- a/src/core/layers/graph_consolidation/graph_consolidation.py
+++ b/src/core/layers/graph_consolidation/graph_consolidation.py
@@ -29,7 +29,6 @@ from src.constants.agents import (
TokenDetail,
)
from src.constants.kg import Node, Predicate
-from src.constants.prompts.janitor_agent import JANITOR_AGENT_GRAPH_NORMALIZATOR_PROMPT
from src.core.agents.architect_agent import ArchitectAgentRelationship
from src.core.agents.janitor_agent import (
JanitorAgent,
diff --git a/src/core/plugins/__init__.py b/src/core/plugins/__init__.py
index 91ef518..cbb37c9 100644
--- a/src/core/plugins/__init__.py
+++ b/src/core/plugins/__init__.py
@@ -1,9 +1,11 @@
-"""
-File: /__init__.py
-Created Date: Monday January 12th 2026
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Monday January 12th 2026 9:22:09 pm
-Modified By: the developer formerly known as Christian Nonis at <[email protected]>
------
-"""
+from src.core.plugins.manager import PluginManager
+from src.core.plugins.manifest import PluginManifest, parse_manifest
+from src.core.plugins.registry import PluginMeta, PluginRegistryClient
+
+__all__ = [
+ "PluginManager",
+ "PluginManifest",
+ "PluginMeta",
+ "PluginRegistryClient",
+ "parse_manifest",
+]
diff --git a/src/core/plugins/cli.py b/src/core/plugins/cli.py
new file mode 100644
index 0000000..740bd73
--- /dev/null
+++ b/src/core/plugins/cli.py
@@ -0,0 +1,162 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+app = typer.Typer(name="plugins", help="BrainAPI plugin management")
+
+PLUGINS_DIR = Path(os.getenv("PLUGINS_DIR", "plugins"))
+REGISTRY_URL = os.getenv("PLUGIN_REGISTRY_URL", "https://registry.brain-api.dev")
+PUBLISHER_ID = os.getenv("PLUGIN_PUBLISHER_ID", "")
+PUBLISHER_API_KEY = os.getenv("PLUGIN_PUBLISHER_API_KEY", "")
+
+
+def _get_manager():
+ from src.core.plugins.manager import PluginManager
+
+ return PluginManager(
+ plugins_dir=PLUGINS_DIR,
+ registry_url=REGISTRY_URL or None,
+ publisher_id=PUBLISHER_ID or None,
+ publisher_api_key=PUBLISHER_API_KEY or None,
+ )
+
+
+def install(
+ name: str = typer.Argument(..., help="Plugin name to install"),
+ version: str = typer.Option("latest", "--version", "-v", help="Plugin version"),
+):
+ manager = _get_manager()
+ try:
+ manifest = manager.install(name, version=version)
+ typer.echo(f"Installed {manifest.name} v{manifest.version}")
+ except Exception as exc:
+ typer.echo(f"Failed to install '{name}': {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+def uninstall(
+ name: str = typer.Argument(..., help="Plugin name to uninstall"),
+):
+ manager = _get_manager()
+ if manager.uninstall(name):
+ typer.echo(f"Uninstalled '{name}'")
+ else:
+ typer.echo(f"Plugin '{name}' not found", err=True)
+ raise typer.Exit(code=1)
+
+
[email protected](name="list")
+def list_plugins(
+ remote: bool = typer.Option(False, "--remote", "-r", help="List available plugins from registry"),
+):
+ manager = _get_manager()
+ if remote:
+ try:
+ plugins = manager.list_available()
+ except Exception as exc:
+ typer.echo(f"Failed to fetch remote plugins: {exc}", err=True)
+ raise typer.Exit(code=1)
+ if not plugins:
+ typer.echo("No plugins available in the registry")
+ return
+ typer.echo("Available plugins:")
+ for p in plugins:
+ typer.echo(f" {p.name} v{p.version} - {p.description}")
+ else:
+ plugins = manager.list_installed()
+ if not plugins:
+ typer.echo("No plugins installed")
+ return
+ typer.echo("Installed plugins:")
+ for p in plugins:
+ typer.echo(f" {p.name} v{p.version} - {p.description}")
+
+
+def info(
+ name: str = typer.Argument(..., help="Plugin name to get info for"),
+):
+ manager = _get_manager()
+ try:
+ meta = manager.get_info(name)
+ typer.echo(f"Name: {meta.name}")
+ typer.echo(f"Version: {meta.version}")
+ typer.echo(f"Author: {meta.author}")
+ typer.echo(f"Description: {meta.description}")
+ if meta.versions:
+ typer.echo(f"Available versions: {', '.join(meta.versions)}")
+ except Exception as exc:
+ typer.echo(f"Failed to get info for '{name}': {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+def update(
+ name: str = typer.Argument(..., help="Plugin name to update"),
+):
+ manager = _get_manager()
+ try:
+ manifest = manager.update(name)
+ typer.echo(f"Updated {manifest.name} to v{manifest.version}")
+ except Exception as exc:
+ typer.echo(f"Failed to update '{name}': {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+def publish(
+ archive: Path = typer.Argument(..., help="Path to plugin archive (.tar.gz)"),
+ name: Optional[str] = typer.Option(None, "--name", "-n", help="Plugin name override"),
+ force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing version"),
+):
+ manager = _get_manager()
+ try:
+ result = manager.publish(archive, name=name, force=force)
+ typer.echo(f"Published: {result}")
+ except Exception as exc:
+ typer.echo(f"Failed to publish: {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+def depublish(
+ name: str = typer.Argument(..., help="Plugin name to remove from registry"),
+ version: Optional[str] = typer.Option(None, "--version", "-v", help="Specific version to remove (omit to remove all)"),
+):
+ manager = _get_manager()
+ try:
+ result = manager.delete_remote(name, version=version)
+ label = f"{name} v{version}" if version else name
+ typer.echo(f"Removed '{label}' from registry: {result}")
+ except Exception as exc:
+ typer.echo(f"Failed to depublish '{name}': {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+def register(
+ publisher_id: Optional[str] = typer.Option(None, "--id", help="Desired publisher ID (auto-generated if omitted)"),
+):
+ manager = _get_manager()
+ try:
+ result = manager.register_publisher(publisher_id=publisher_id)
+ typer.echo("")
+ typer.echo(f" Publisher registered successfully!")
+ typer.echo(f" Publisher ID: {result['publisher_id']}")
+ typer.echo(f" API Key: {result['api_key']}")
+ typer.echo("")
+ typer.echo(" Save these to your environment:")
+ typer.echo(f" export PLUGIN_PUBLISHER_ID={result['publisher_id']}")
+ typer.echo(f" export PLUGIN_PUBLISHER_API_KEY={result['api_key']}")
+ typer.echo("")
+ except Exception as exc:
+ typer.echo(f"Failed to register: {exc}", err=True)
+ raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+ app()
diff --git a/src/core/plugins/context.py b/src/core/plugins/context.py
new file mode 100644
index 0000000..0bf5e7e
--- /dev/null
+++ b/src/core/plugins/context.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+from src.adapters.cache import CacheAdapter
+from src.adapters.data import DataAdapter
+from src.adapters.embeddings import EmbeddingsAdapter, VectorStoreAdapter
+from src.adapters.graph import GraphAdapter
+from src.adapters.llm import LLMAdapter
+from src.core.plugins.prompts import PromptRegistry, prompt_registry
+
+if TYPE_CHECKING:
+ from fastapi import APIRouter, FastAPI
+ from mcp.server import FastMCP
+ from src.config import Config
+
+
+class PluginAdapters:
+ def __init__(
+ self,
+ cache: CacheAdapter,
+ graph: GraphAdapter,
+ data: DataAdapter,
+ vector_store: VectorStoreAdapter,
+ llm_small: LLMAdapter,
+ llm_large: LLMAdapter,
+ embeddings: EmbeddingsAdapter,
+ embeddings_small: EmbeddingsAdapter,
+ ):
+ self.cache = cache
+ self.graph = graph
+ self.data = data
+ self.vector_store = vector_store
+ self.llm_small = llm_small
+ self.llm_large = llm_large
+ self.embeddings = embeddings
+ self.embeddings_small = embeddings_small
+
+
+class PluginContext:
+ def __init__(
+ self,
+ adapters: PluginAdapters,
+ prompts: PromptRegistry,
+ config: "Config",
+ app: Optional["FastAPI"] = None,
+ mcp: Optional["FastMCP"] = None,
+ ):
+ self._app = app
+ self.mcp = mcp
+ self.adapters = adapters
+ self.prompts = prompts
+ self.config = config
+ self._routers: list[tuple["APIRouter", dict[str, Any]]] = []
+ self._event_handlers: dict[str, list[Callable]] = {}
+
+ @classmethod
+ def _build_adapters(cls) -> PluginAdapters:
+ from src.core.instances import (
+ cache_adapter,
+ data_adapter,
+ embeddings_adapter,
+ embeddings_small_adapter,
+ graph_adapter,
+ llm_large_adapter,
+ llm_small_adapter,
+ vector_store_adapter,
+ )
+
+ return PluginAdapters(
+ cache=cache_adapter,
+ graph=graph_adapter,
+ data=data_adapter,
+ vector_store=vector_store_adapter,
+ llm_small=llm_small_adapter,
+ llm_large=llm_large_adapter,
+ embeddings=embeddings_adapter,
+ embeddings_small=embeddings_small_adapter,
+ )
+
+ @classmethod
+ def from_app(cls, app: "FastAPI") -> "PluginContext":
+ from src.config import config
+
+ return cls(
+ app=app,
+ adapters=cls._build_adapters(),
+ prompts=prompt_registry,
+ config=config,
+ )
+
+ @classmethod
+ def from_mcp(cls, mcp: "FastMCP") -> "PluginContext":
+ from src.config import config
+
+ return cls(
+ mcp=mcp,
+ adapters=cls._build_adapters(),
+ prompts=prompt_registry,
+ config=config,
+ )
+
+ def include_router(
+ self,
+ router: "APIRouter",
+ skip_pat: bool = False,
+ skip_brain: bool = False,
+ **kwargs: Any,
+ ) -> None:
+ if self._app is None:
+ return
+ self._app.include_router(router, **kwargs)
+ self._routers.append((router, kwargs))
+
+ prefix = kwargs.get("prefix", "") or getattr(router, "prefix", "")
+ if prefix:
+ if skip_pat:
+ from src.services.api.middlewares.auth import BrainPATMiddleware
+ BrainPATMiddleware.excluded_prefixes.add(prefix)
+ if skip_brain:
+ from src.services.api.middlewares.brains import BrainMiddleware
+ BrainMiddleware.excluded_prefixes.add(prefix)
+
+ def add_middleware(self, middleware_cls: type, **kwargs: Any) -> None:
+ if self._app is None:
+ return
+ self._app.add_middleware(middleware_cls, **kwargs)
+
+ def register_mcp_tool(self, fn: Callable, **kwargs: Any) -> None:
+ if self.mcp is None:
+ return
+ self.mcp.tool(**kwargs)(fn)
+
+ def add_event_handler(self, event: str, handler: Callable) -> None:
+ self._event_handlers.setdefault(event, []).append(handler)
diff --git a/src/core/plugins/loader.py b/src/core/plugins/loader.py
new file mode 100644
index 0000000..1ce507b
--- /dev/null
+++ b/src/core/plugins/loader.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import importlib
+import logging
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from src.core.plugins.manifest import MANIFEST_FILENAME, PluginManifest, parse_manifest
+
+if TYPE_CHECKING:
+ from src.core.plugins.context import PluginContext
+
+logger = logging.getLogger("brainapi.plugins")
+
+
+class PluginLoader:
+ def __init__(self, plugins_dir: Path, context: "PluginContext"):
+ self.plugins_dir = plugins_dir
+ self.context = context
+ self._loaded: dict[str, PluginManifest] = {}
+
+ def discover(self) -> list[PluginManifest]:
+ if not self.plugins_dir.exists():
+ logger.info("Plugins directory '%s' does not exist, skipping discovery", self.plugins_dir)
+ return []
+
+ manifests: list[PluginManifest] = []
+ for child in sorted(self.plugins_dir.iterdir()):
+ if not child.is_dir():
+ continue
+ manifest_path = child / MANIFEST_FILENAME
+ if not manifest_path.exists():
+ continue
+ try:
+ manifest = parse_manifest(manifest_path)
+ errors = manifest.validate()
+ if errors:
+ logger.warning(
+ "Plugin '%s' manifest validation failed: %s",
+ child.name,
+ "; ".join(errors),
+ )
+ continue
+ manifests.append(manifest)
+ except Exception as exc:
+ logger.warning("Failed to parse manifest in '%s': %s", child.name, exc)
+
+ manifests.sort(key=lambda m: m.priority)
+ return manifests
+
+ def install_dependencies(self, manifest: PluginManifest) -> None:
+ if not manifest.pip_dependencies:
+ return
+ logger.info("Installing pip dependencies for plugin '%s': %s", manifest.name, manifest.pip_dependencies)
+ cmd = self._build_install_cmd(manifest.pip_dependencies)
+ try:
+ subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+ except subprocess.CalledProcessError as exc:
+ logger.error(
+ "Failed to install dependencies for plugin '%s': %s",
+ manifest.name,
+ exc.stderr.decode() if exc.stderr else str(exc),
+ )
+ raise
+
+ @staticmethod
+ def _build_install_cmd(packages: list[str]) -> list[str]:
+ if shutil.which("uv"):
+ return ["uv", "pip", "install", "--quiet", *packages]
+ return [sys.executable, "-m", "pip", "install", "--quiet", *packages]
+
+ def load(self, manifest: PluginManifest) -> bool:
+ if manifest.name in self._loaded:
+ logger.debug("Plugin '%s' already loaded, skipping", manifest.name)
+ return True
+
+ plugin_dir = manifest.plugin_dir
+ if plugin_dir is None:
+ logger.error("Plugin '%s' has no plugin_dir set", manifest.name)
+ return False
+
+ try:
+ self.install_dependencies(manifest)
+ except Exception:
+ return False
+
+ plugin_dir_str = str(plugin_dir)
+ if plugin_dir_str not in sys.path:
+ sys.path.insert(0, plugin_dir_str)
+
+ module_name = manifest.entry_point.replace("/", ".").rstrip(".py")
+ if module_name == "__init__":
+ module_name = plugin_dir.name
+
+ try:
+ module = importlib.import_module(module_name)
+ except Exception as exc:
+ logger.error("Failed to import plugin '%s' (module: %s): %s", manifest.name, module_name, exc)
+ if plugin_dir_str in sys.path:
+ sys.path.remove(plugin_dir_str)
+ return False
+
+ register_fn = getattr(module, "register", None)
+ if register_fn is None or not callable(register_fn):
+ logger.error("Plugin '%s' has no callable 'register' function in '%s'", manifest.name, module_name)
+ if plugin_dir_str in sys.path:
+ sys.path.remove(plugin_dir_str)
+ return False
+
+ try:
+ register_fn(self.context)
+ self._loaded[manifest.name] = manifest
+ logger.info("Plugin '%s' v%s loaded successfully", manifest.name, manifest.version)
+ return True
+ except Exception as exc:
+ logger.error("Plugin '%s' register() raised an exception: %s", manifest.name, exc, exc_info=True)
+ if plugin_dir_str in sys.path:
+ sys.path.remove(plugin_dir_str)
+ return False
+
+ def load_all(self) -> dict[str, bool]:
+ manifests = self.discover()
+ results: dict[str, bool] = {}
+ for manifest in manifests:
+ try:
+ results[manifest.name] = self.load(manifest)
+ except Exception as exc:
+ logger.error("Unexpected error loading plugin '%s': %s", manifest.name, exc, exc_info=True)
+ results[manifest.name] = False
+ loaded_count = sum(1 for v in results.values() if v)
+ total = len(results)
+ if total > 0:
+ logger.info("Loaded %d/%d plugins", loaded_count, total)
+ return results
+
+ @property
+ def loaded_plugins(self) -> dict[str, PluginManifest]:
+ return dict(self._loaded)
diff --git a/src/core/plugins/manager.py b/src/core/plugins/manager.py
new file mode 100644
index 0000000..a666a2d
--- /dev/null
+++ b/src/core/plugins/manager.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from src.core.plugins.manifest import MANIFEST_FILENAME, PluginManifest, parse_manifest
+from src.core.plugins.registry import PluginMeta, PluginRegistryClient
+
+logger = logging.getLogger("brainapi.plugins.manager")
+
+
+class PluginManager:
+ def __init__(
+ self,
+ plugins_dir: Path,
+ registry_url: Optional[str] = None,
+ publisher_id: Optional[str] = None,
+ publisher_api_key: Optional[str] = None,
+ ):
+ self.plugins_dir = plugins_dir
+ self.registry_url = registry_url
+ self._registry: Optional[PluginRegistryClient] = None
+ if registry_url:
+ self._registry = PluginRegistryClient(
+ registry_url=registry_url,
+ publisher_id=publisher_id,
+ api_key=publisher_api_key,
+ )
+
+ def _ensure_registry(self) -> PluginRegistryClient:
+ if self._registry is None:
+ raise RuntimeError(
+ "No plugin registry configured. "
+ "Set PLUGIN_REGISTRY_URL environment variable or pass registry_url."
+ )
+ return self._registry
+
+ def install(self, name: str, version: str = "latest") -> PluginManifest:
+ existing_dir = self.plugins_dir / name
+ existing_manifest = existing_dir / MANIFEST_FILENAME
+ if existing_manifest.exists():
+ try:
+ current = parse_manifest(existing_manifest)
+ if version == "latest" or current.version == version:
+ logger.info("Plugin '%s' v%s already installed, skipping", name, current.version)
+ return current
+ except Exception:
+ pass
+
+ registry = self._ensure_registry()
+ plugin_dir = registry.download(name, version=version, target_dir=self.plugins_dir)
+
+ manifest_path = plugin_dir / MANIFEST_FILENAME
+ if not manifest_path.exists():
+ raise FileNotFoundError(
+ f"Downloaded plugin '{name}' does not contain a {MANIFEST_FILENAME}"
+ )
+
+ manifest = parse_manifest(manifest_path)
+ errors = manifest.validate()
+ if errors:
+ shutil.rmtree(plugin_dir, ignore_errors=True)
+ raise ValueError(
+ f"Plugin '{name}' manifest validation failed: {'; '.join(errors)}"
+ )
+
+ logger.info("Installed plugin '%s' v%s to '%s'", manifest.name, manifest.version, plugin_dir)
+ return manifest
+
+ def uninstall(self, name: str) -> bool:
+ plugin_dir = self.plugins_dir / name
+ if not plugin_dir.exists():
+ logger.warning("Plugin '%s' not found in '%s'", name, self.plugins_dir)
+ return False
+
+ shutil.rmtree(plugin_dir)
+ logger.info("Uninstalled plugin '%s'", name)
+ return True
+
+ def list_installed(self) -> list[PluginManifest]:
+ if not self.plugins_dir.exists():
+ return []
+
+ manifests: list[PluginManifest] = []
+ for child in sorted(self.plugins_dir.iterdir()):
+ if not child.is_dir():
+ continue
+ manifest_path = child / MANIFEST_FILENAME
+ if not manifest_path.exists():
+ continue
+ try:
+ manifests.append(parse_manifest(manifest_path))
+ except Exception as exc:
+ logger.warning("Skipping '%s': %s", child.name, exc)
+
+ return manifests
+
+ def list_available(self) -> list[PluginMeta]:
+ registry = self._ensure_registry()
+ return registry.list_plugins()
+
+ def get_info(self, name: str) -> PluginMeta:
+ registry = self._ensure_registry()
+ return registry.get_plugin_info(name)
+
+ def update(self, name: str) -> PluginManifest:
+ return self.install(name, version="latest")
+
+ def publish(self, archive_path: Path, name: Optional[str] = None, force: bool = False) -> dict:
+ registry = self._ensure_registry()
+ return registry.publish(archive_path, name=name, force=force)
+
+ def delete_remote(self, name: str, version: Optional[str] = None) -> dict:
+ registry = self._ensure_registry()
+ return registry.delete(name, version=version)
+
+ def register_publisher(self, publisher_id: Optional[str] = None) -> dict:
+ if not self.registry_url:
+ raise RuntimeError(
+ "No plugin registry configured. "
+ "Set PLUGIN_REGISTRY_URL environment variable or pass registry_url."
+ )
+ client = PluginRegistryClient(registry_url=self.registry_url)
+ return client.register_publisher(publisher_id=publisher_id)
diff --git a/src/core/plugins/manifest.py b/src/core/plugins/manifest.py
new file mode 100644
index 0000000..c4f7dd6
--- /dev/null
+++ b/src/core/plugins/manifest.py
@@ -0,0 +1,64 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+MANIFEST_FILENAME = "plugin.yaml"
+
+REQUIRED_FIELDS = ("name", "version", "entry_point")
+
+
+@dataclass
+class PluginManifest:
+ name: str
+ version: str
+ entry_point: str
+ description: str = ""
+ author: str = ""
+ brainapi_version: str = ""
+ priority: int = 100
+ pip_dependencies: list[str] = field(default_factory=list)
+ tags: list[str] = field(default_factory=list)
+ plugin_dir: Optional[Path] = None
+
+ def validate(self) -> list[str]:
+ errors: list[str] = []
+ if not self.name or not self.name.strip():
+ errors.append("'name' is required and cannot be empty")
+ if not self.version or not self.version.strip():
+ errors.append("'version' is required and cannot be empty")
+ if not self.entry_point or not self.entry_point.strip():
+ errors.append("'entry_point' is required and cannot be empty")
+ if self.plugin_dir and not self.plugin_dir.is_dir():
+ errors.append(f"plugin_dir '{self.plugin_dir}' is not a valid directory")
+ return errors
+
+
+def parse_manifest(manifest_path: Path) -> PluginManifest:
+ if not manifest_path.exists():
+ raise FileNotFoundError(f"Manifest not found: {manifest_path}")
+
+ with open(manifest_path, "r", encoding="utf-8") as f:
+ data = yaml.safe_load(f)
+
+ if not isinstance(data, dict):
+ raise ValueError(f"Invalid manifest format in {manifest_path}: expected a YAML mapping")
+
+ for field_name in REQUIRED_FIELDS:
+ if field_name not in data:
+ raise ValueError(f"Missing required field '{field_name}' in {manifest_path}")
+
+ return PluginManifest(
+ name=str(data["name"]),
+ version=str(data["version"]),
+ entry_point=str(data["entry_point"]),
+ description=str(data.get("description", "")),
+ author=str(data.get("author", "")),
+ brainapi_version=str(data.get("brainapi_version", "")),
+ priority=int(data.get("priority", 100)),
+ pip_dependencies=list(data.get("pip_dependencies", [])),
+ tags=[str(t) for t in data.get("tags", [])],
+ plugin_dir=manifest_path.parent,
+ )
diff --git a/src/core/plugins/prompts.py b/src/core/plugins/prompts.py
new file mode 100644
index 0000000..6fa1946
--- /dev/null
+++ b/src/core/plugins/prompts.py
@@ -0,0 +1,58 @@
+from threading import Lock
+from typing import Optional
+
+
+class PromptRegistry:
+ _instance: Optional["PromptRegistry"] = None
+ _lock: Lock = Lock()
+
+ def __init__(self):
+ self._overrides: dict[str, str] = {}
+ self._extensions: dict[str, list[str]] = {}
+ self._defaults: dict[str, str] = {}
+
+ @classmethod
+ def get_instance(cls) -> "PromptRegistry":
+ if cls._instance is None:
+ with cls._lock:
+ if cls._instance is None:
+ cls._instance = cls()
+ return cls._instance
+
+ def register_default(self, prompt_name: str, default_value: str) -> None:
+ self._defaults[prompt_name] = default_value
+
+ def override(self, prompt_name: str, new_prompt: str) -> None:
+ self._overrides[prompt_name] = new_prompt
+
+ def extend(self, prompt_name: str, suffix: str) -> None:
+ self._extensions.setdefault(prompt_name, []).append(suffix)
+
+ def get(self, prompt_name: str, default: Optional[str] = None) -> str:
+ if prompt_name in self._overrides:
+ return self._overrides[prompt_name]
+
+ base = default if default is not None else self._defaults.get(prompt_name, "")
+
+ extensions = self._extensions.get(prompt_name, [])
+ if extensions:
+ return base + "\n" + "\n".join(extensions)
+
+ return base
+
+ def reset(self, prompt_name: Optional[str] = None) -> None:
+ if prompt_name:
+ self._overrides.pop(prompt_name, None)
+ self._extensions.pop(prompt_name, None)
+ else:
+ self._overrides.clear()
+ self._extensions.clear()
+
+ def list_overrides(self) -> list[str]:
+ return list(self._overrides.keys())
+
+ def list_extensions(self) -> list[str]:
+ return list(self._extensions.keys())
+
+
+prompt_registry = PromptRegistry.get_instance()
diff --git a/src/core/plugins/registry.py b/src/core/plugins/registry.py
new file mode 100644
index 0000000..ca4775d
--- /dev/null
+++ b/src/core/plugins/registry.py
@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import logging
+import os
+import tarfile
+import tempfile
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+
+logger = logging.getLogger("brainapi.plugins.registry")
+
+
+@dataclass
+class PluginMeta:
+ name: str
+ version: str
+ description: str = ""
+ author: str = ""
+ versions: list[str] = field(default_factory=list)
+
+ @classmethod
+ def from_dict(cls, data: dict[str, Any]) -> "PluginMeta":
+ return cls(
+ name=data.get("name", ""),
+ version=data.get("version", ""),
+ description=data.get("description", ""),
+ author=data.get("author", ""),
+ versions=data.get("versions", []),
+ )
+
+
+class PluginRegistryClient:
+ def __init__(
+ self,
+ registry_url: str,
+ publisher_id: Optional[str] = None,
+ api_key: Optional[str] = None,
+ timeout: float = 60.0,
+ ):
+ self.registry_url = registry_url.rstrip("/")
+ self.publisher_id = publisher_id
+ self.api_key = api_key
+ self.timeout = timeout
+
+ def _headers(self, with_publisher: bool = False) -> dict[str, str]:
+ headers: dict[str, str] = {"Accept": "application/json"}
+ if self.api_key:
+ headers["Authorization"] = f"Bearer {self.api_key}"
+ if with_publisher and self.publisher_id:
+ headers["X-Publisher-Id"] = self.publisher_id
+ return headers
+
+ def register_publisher(self, publisher_id: Optional[str] = None) -> dict[str, Any]:
+ payload = {}
+ if publisher_id:
+ payload["publisher_id"] = publisher_id
+ with httpx.Client(timeout=self.timeout) as client:
+ response = client.post(self._url("/publishers"), json=payload)
+ response.raise_for_status()
+ return response.json()
+
+ def _url(self, path: str) -> str:
+ return f"{self.registry_url}/{path.lstrip('/')}"
+
+ def list_plugins(self) -> list[PluginMeta]:
+ with httpx.Client(timeout=self.timeout) as client:
+ response = client.get(self._url("/plugins"), headers=self._headers())
+ response.raise_for_status()
+ data = response.json()
+
+ plugins = data if isinstance(data, list) else data.get("plugins", [])
+ return [PluginMeta.from_dict(p) for p in plugins]
+
+ def get_plugin_info(self, name: str) -> PluginMeta:
+ with httpx.Client(timeout=self.timeout) as client:
+ response = client.get(self._url(f"/plugins/{name}"), headers=self._headers())
+ response.raise_for_status()
+ return PluginMeta.from_dict(response.json())
+
+ def download(self, name: str, version: str = "latest", target_dir: Optional[Path] = None) -> Path:
+ url = self._url(f"/plugins/{name}/versions/{version}/download")
+
+ with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
+ response = client.get(url, headers=self._headers())
+ response.raise_for_status()
+
+ with tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False) as tmp:
+ tmp.write(response.content)
+ tmp_path = Path(tmp.name)
+
+ extract_dir = tempfile.mkdtemp()
+ try:
+ if target_dir is None:
+ target_dir = Path("plugins")
+ target_dir.mkdir(parents=True, exist_ok=True)
+
+ with tarfile.open(tmp_path, "r:gz") as tar:
+ tar.extractall(extract_dir)
+
+ manifest_file = None
+ for root, _dirs, files in os.walk(extract_dir):
+ if "plugin.yaml" in files:
+ manifest_file = Path(root) / "plugin.yaml"
+ break
+
+ if manifest_file is None:
+ raise FileNotFoundError("plugin.yaml not found in archive")
+
+ source_dir = manifest_file.parent
+
+ plugin_dir = target_dir / name
+ if plugin_dir.exists():
+ shutil.rmtree(plugin_dir)
+ shutil.copytree(source_dir, plugin_dir)
+
+ logger.info("Downloaded plugin '%s' v%s to '%s'", name, version, plugin_dir)
+ return plugin_dir
+ finally:
+ tmp_path.unlink(missing_ok=True)
+ shutil.rmtree(extract_dir, ignore_errors=True)
+
+ def publish(self, archive_path: Path, name: Optional[str] = None, force: bool = False) -> dict[str, Any]:
+ url = self._url("/plugins")
+ if force:
+ url += "?force=true"
+ headers = self._headers(with_publisher=True)
+ headers.pop("Accept", None)
+
+ with open(archive_path, "rb") as f:
+ files = {"archive": (archive_path.name, f, "application/gzip")}
+ data = {}
+ if name:
+ data["name"] = name
+
+ with httpx.Client(timeout=self.timeout) as client:
+ response = client.post(url, headers=headers, files=files, data=data)
+ response.raise_for_status()
+ return response.json()
+
+ def delete(self, name: str, version: Optional[str] = None) -> dict[str, Any]:
+ path = f"/plugins/{name}/versions/{version}" if version else f"/plugins/{name}"
+ with httpx.Client(timeout=self.timeout) as client:
+ response = client.delete(self._url(path), headers=self._headers(with_publisher=True))
+ response.raise_for_status()
+ return response.json()
diff --git a/src/services/api/app.py b/src/services/api/app.py
index c564a22..5902e27 100644
--- a/src/services/api/app.py
+++ b/src/services/api/app.py
@@ -1,19 +1,11 @@
-"""
-File: /app.py
-Created Date: Sunday October 19th 2025
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Monday February 9th 2026 9:48:30 pm
-Modified By: Christian Nonis <[email protected]>
------
-"""
-
+import logging
import os
+from contextlib import asynccontextmanager
from pathlib import Path
import dotenv
-_project_root = Path(__file__).resolve().parent.parent.parent
+_project_root = Path(__file__).resolve().parent.parent.parent.parent
dotenv.load_dotenv(_project_root / ".env")
from fastapi import FastAPI, Response
@@ -23,13 +15,98 @@ from uvicorn import run
from src.services.api.middlewares.auth import BrainPATMiddleware
from src.services.api.middlewares.brains import BrainMiddleware
from src.services.api.routes.ingest import ingest_router
-from src.services.api.routes.retrieve import retrieve_router
from src.services.api.routes.meta import meta_router
from src.services.api.routes.model import model_router
+from src.services.api.routes.retrieve import retrieve_router
from src.services.api.routes.system import system_router
from src.services.api.routes.tasks import tasks_router
-app = FastAPI(debug=os.getenv("ENV") == "development")
+logger = logging.getLogger("brainapi.plugins")
+
+PLUGINS_DIR = Path(os.getenv("PLUGINS_DIR", str(_project_root / "plugins")))
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+ from src.core.plugins.context import PluginContext
+ from src.core.plugins.loader import PluginLoader
+
+ ctx = PluginContext.from_app(app)
+ loader = PluginLoader(plugins_dir=PLUGINS_DIR, context=ctx)
+ results = loader.load_all()
+
+ _log_plugin_banner(loader, results)
+
+ for event_name, handlers in ctx._event_handlers.items():
+ if event_name == "startup":
+ for handler in handlers:
+ await handler() if _is_coroutine(handler) else handler()
+
+ yield
+
+ for event_name, handlers in ctx._event_handlers.items():
+ if event_name == "shutdown":
+ for handler in handlers:
+ await handler() if _is_coroutine(handler) else handler()
+
+
+def _is_coroutine(fn):
+ import asyncio
+ return asyncio.iscoroutinefunction(fn)
+
+
+def _log_plugin_banner(loader, results: dict[str, bool]):
+ loaded = loader.loaded_plugins
+ total = len(results)
+ ok = sum(1 for v in results.values() if v)
+ failed = total - ok
+
+ lines = [
+ "",
+ "\033[36m ╔══════════════════════════════════════════════════════╗\033[0m",
+ "\033[36m ║\033[0m \033[1;36m⚡ BrainAPI Plugin System ⚡\033[0m \033[36m║\033[0m",
+ "\033[36m ╠══════════════════════════════════════════════════════╣\033[0m",
+ ]
+
+ if total == 0:
+ lines.append(
+ "\033[36m ║\033[0m \033[2mNo plugins installed\033[0m \033[36m║\033[0m"
+ )
+ else:
+ for name, success in results.items():
+ manifest = loaded.get(name)
+ if success and manifest:
+ ver = f"v{manifest.version}"
+ status = "\033[32m✔ loaded\033[0m"
+ label = f"{manifest.name} ({ver})"
+ else:
+ status = "\033[31m✘ failed\033[0m"
+ label = name
+ padded = f" {status} {label}"
+ visible_len = len(f" ✔ loaded {label}")
+ pad = 54 - visible_len
+ lines.append(f"\033[36m ║\033[0m{padded}{' ' * max(pad, 1)}\033[36m║\033[0m")
+
+ lines.append("\033[36m ╠══════════════════════════════════════════════════════╣\033[0m")
+
+ summary_parts = [f"\033[1;32m{ok} loaded\033[0m"]
+ if failed:
+ summary_parts.append(f"\033[1;31m{failed} failed\033[0m")
+ summary_text = f" {' · '.join(summary_parts)}"
+ visible_summary_len = len(f" {ok} loaded" + (f" · {failed} failed" if failed else ""))
+ summary_pad = 54 - visible_summary_len
+ lines.append(f"\033[36m ║\033[0m{summary_text}{' ' * max(summary_pad, 1)}\033[36m║\033[0m")
+
+ lines.append("\033[36m ╚══════════════════════════════════════════════════════╝\033[0m")
+ lines.append("")
+
+ print("\n".join(lines))
+
+
+app = FastAPI(
+ debug=os.getenv("ENV") == "development",
+ lifespan=lifespan,
+)
app.add_middleware(BrainPATMiddleware)
app.add_middleware(BrainMiddleware)
@@ -41,7 +118,6 @@ app.add_middleware(
allow_headers=["*"],
)
-
app.include_router(ingest_router)
app.include_router(retrieve_router)
app.include_router(meta_router)
diff --git a/src/services/api/middlewares/auth.py b/src/services/api/middlewares/auth.py
index ef42031..45b76c3 100644
--- a/src/services/api/middlewares/auth.py
+++ b/src/services/api/middlewares/auth.py
@@ -3,7 +3,7 @@ File: /auth.py
Created Date: Thursday November 27th 2025
Author: Christian Nonis <[email protected]>
-----
-Last Modified: Thursday November 27th 2025 10:20:03 pm
+Last Modified: Thursday February 19th 2026 7:45:12 pm
Modified By: Christian Nonis <[email protected]>
-----
"""
@@ -19,10 +19,15 @@ from src.services.data.main import data_adapter
class BrainPATMiddleware(BaseHTTPMiddleware):
+ excluded_prefixes: set[str] = set()
+
async def dispatch(self, request: Request, call_next):
if request.method == "OPTIONS":
return await call_next(request)
+ if any(request.url.path.startswith(p) for p in self.excluded_prefixes):
+ return await call_next(request)
+
# Variables ----------------------------------------------
brainpat = request.headers.get("BrainPAT") or getattr(
request.state, "pat", None
@@ -34,7 +39,7 @@ class BrainPATMiddleware(BaseHTTPMiddleware):
if brainpat:
brainpat = brainpat.rstrip()
system_pat = os.getenv("BRAINPAT_TOKEN")
-
+ print(brainpat, system_pat)
if request.url.path.startswith("/system") or request.url.path == "/":
if brainpat == system_pat:
return await call_next(request)
diff --git a/src/services/api/middlewares/brains.py b/src/services/api/middlewares/brains.py
index 0bd29f1..dc7f704 100644
--- a/src/services/api/middlewares/brains.py
+++ b/src/services/api/middlewares/brains.py
@@ -43,7 +43,12 @@ def _brain_id_from_multipart(body: bytes, content_type: str) -> str | None:
class BrainMiddleware(BaseHTTPMiddleware):
+ excluded_prefixes: set[str] = set()
+
async def dispatch(self, request: Request, call_next):
+ if any(request.url.path.startswith(p) for p in self.excluded_prefixes):
+ return await call_next(request)
+
async def _get_brain_id():
brain_id = None
diff --git a/src/services/data/main.py b/src/services/data/main.py
index e25aef1..c5307d0 100644
--- a/src/services/data/main.py
+++ b/src/services/data/main.py
@@ -1,15 +1,5 @@
-"""
-File: /main.py
-Created Date: Saturday October 25th 2025
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Saturday October 25th 2025 12:11:27 pm
-Modified By: the developer formerly known as Christian Nonis at <[email protected]>
------
-"""
+from src.core.instances import data_adapter
-from src.adapters.data import DataAdapter
-from src.lib.mongo.client import _mongo_client
-
-data_adapter = DataAdapter()
-data_adapter.add_client(_mongo_client)
+__all__ = [
+ "data_adapter",
+]
diff --git a/src/services/input/agents.py b/src/services/input/agents.py
index 3a2b7f2..d7c3b0a 100644
--- a/src/services/input/agents.py
+++ b/src/services/input/agents.py
@@ -1,77 +1,19 @@
-"""
-File: /agents.py
-Created Date: Sunday December 21st 2025
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Thursday February 19th 2026 7:45:12 pm
-Modified By: Christian Nonis <[email protected]>
------
-"""
-
-from src.adapters.cache import CacheAdapter
-from src.adapters.embeddings import EmbeddingsAdapter, VectorStoreAdapter
-from src.adapters.graph import GraphAdapter
-from src.adapters.llm import LLMAdapter
-from src.config import config
-from src.lib.milvus.client import _milvus_client
-from src.lib.neo4j.client import _neo4j_client
-from src.lib.redis.client import _redis_client
-
-_MODES = ("local", "remote")
-
-
-def _require_mode():
- if config.models_mode not in _MODES:
- raise ValueError(f"Invalid models mode: {config.models_mode}")
- return config.models_mode == "local"
-
-
-_is_local = _require_mode()
-
-if _is_local:
- from src.lib.llm.client_ollama import _llm_large_client, _llm_small_client
-
- _llm_small = LLMAdapter()
- _llm_small.add_client(_llm_small_client)
- _llm_large = LLMAdapter()
- _llm_large.add_client(_llm_large_client)
-else:
- from src.lib.llm.client_large import _llm_large_client
- from src.lib.llm.client_small import _llm_small_client
-
- _llm_small = LLMAdapter()
- _llm_small.add_client(_llm_small_client)
- _llm_large = LLMAdapter()
- _llm_large.add_client(_llm_large_client)
-
-llm_small_adapter = _llm_small
-llm_large_adapter = _llm_large
-
-cache_adapter = CacheAdapter()
-cache_adapter.add_client(_redis_client)
-
-graph_adapter = GraphAdapter()
-graph_adapter.add_client(_neo4j_client)
-
-if _is_local:
- from src.lib.embeddings.local import _embeddings_local_client
- from src.lib.embeddings.client_small import _embeddings_small_client
-
- _embeddings_primary = EmbeddingsAdapter()
- _embeddings_primary.add_client(_embeddings_local_client)
- _embeddings_small = EmbeddingsAdapter()
- _embeddings_small.add_client(_embeddings_small_client)
-else:
- from src.lib.embeddings.client import _embeddings_client
- from src.lib.embeddings.client_small import _embeddings_small_client
-
- _embeddings_primary = EmbeddingsAdapter()
- _embeddings_primary.add_client(_embeddings_client)
- _embeddings_small = EmbeddingsAdapter()
- _embeddings_small.add_client(_embeddings_small_client)
-
-embeddings_adapter = _embeddings_primary
-embeddings_small_adapter = _embeddings_small
-
-vector_store_adapter = VectorStoreAdapter()
-vector_store_adapter.add_client(_milvus_client)
+from src.core.instances import (
+ cache_adapter,
+ embeddings_adapter,
+ embeddings_small_adapter,
+ graph_adapter,
+ llm_large_adapter,
+ llm_small_adapter,
+ vector_store_adapter,
+)
+
+__all__ = [
+ "cache_adapter",
+ "embeddings_adapter",
+ "embeddings_small_adapter",
+ "graph_adapter",
+ "llm_large_adapter",
+ "llm_small_adapter",
+ "vector_store_adapter",
+]
diff --git a/src/services/kg_agent/main.py b/src/services/kg_agent/main.py
index f36524c..207e188 100644
--- a/src/services/kg_agent/main.py
+++ b/src/services/kg_agent/main.py
@@ -1,68 +1,11 @@
-"""
-File: /main.py
-Created Date: Sunday October 19th 2025
-Author: Christian Nonis <[email protected]>
------
-Last Modified: Sunday October 19th 2025 10:28:43 am
-Modified By: the developer formerly known as Christian Nonis at <[email protected]>
------
-"""
-
-from src.adapters.cache import CacheAdapter
-from src.adapters.embeddings import EmbeddingsAdapter, VectorStoreAdapter
-from src.adapters.graph import GraphAdapter
-from src.adapters.llm import LLMAdapter
-from src.config import config
from src.core.agents.kg_agent import KGAgent
-from src.lib.milvus.client import _milvus_client
-from src.lib.neo4j.client import _neo4j_client
-from src.lib.redis.client import _redis_client
-
-_MODES = ("local", "remote")
-
-
-def _require_mode():
- if config.models_mode not in _MODES:
- raise ValueError(f"Invalid models mode: {config.models_mode}")
- return config.models_mode == "local"
-
-
-_is_local = _require_mode()
-
-if _is_local:
- from src.lib.llm.client_ollama import _llm_large_client
-
- _llm_large = LLMAdapter()
- _llm_large.add_client(_llm_large_client)
-else:
- from src.lib.llm.client_large import _llm_large_client
-
- _llm_large = LLMAdapter()
- _llm_large.add_client(_llm_large_client)
-
-llm_large_adapter = _llm_large
-
-cache_adapter = CacheAdapter()
-cache_adapter.add_client(_redis_client)
-
-graph_adapter = GraphAdapter()
-graph_adapter.add_client(_neo4j_client)
-
-if _is_local:
- from src.lib.embeddings.local import _embeddings_local_client
-
- _embeddings = EmbeddingsAdapter()
- _embeddings.add_client(_embeddings_local_client)
-else:
- from src.lib.embeddings.client import _embeddings_client
-
- _embeddings = EmbeddingsAdapter()
- _embeddings.add_client(_embeddings_client)
-
-embeddings_adapter = _embeddings
-
-vector_store_adapter = VectorStoreAdapter()
-vector_store_adapter.add_client(_milvus_client)
+from src.core.instances import (
+ cache_adapter,
+ embeddings_adapter,
+ graph_adapter,
+ llm_large_adapter,
+ vector_store_adapter,
+)
kg_agent = KGAgent(
llm_large_adapter,
@@ -72,3 +15,12 @@ kg_agent = KGAgent(
embeddings=embeddings_adapter,
database_desc=graph_adapter.graphdb_description,
)
+
+__all__ = [
+ "cache_adapter",
+ "embeddings_adapter",
+ "graph_adapter",
+ "kg_agent",
+ "llm_large_adapter",
+ "vector_store_adapter",
+]
diff --git a/src/services/mcp/app.py b/src/services/mcp/app.py
index d784c67..01f19e2 100644
--- a/src/services/mcp/app.py
+++ b/src/services/mcp/app.py
@@ -1,3 +1,5 @@
+import logging
+import os
from pathlib import Path
import dotenv
@@ -6,11 +8,74 @@ from starlette.middleware import Middleware
from starlette.responses import JSONResponse
from starlette.routing import Route
-_project_root = Path(__file__).resolve().parent.parent.parent
+_project_root = Path(__file__).resolve().parent.parent.parent.parent
dotenv.load_dotenv(_project_root / ".env")
from src.services.mcp.main import auth_token_var, mcp
+PLUGINS_DIR = Path(os.getenv("PLUGINS_DIR", str(_project_root / "plugins")))
+
+logger = logging.getLogger("brainapi.plugins")
+
+
+def _load_mcp_plugins():
+ from src.core.plugins.context import PluginContext
+ from src.core.plugins.loader import PluginLoader
+
+ ctx = PluginContext.from_mcp(mcp)
+ loader = PluginLoader(plugins_dir=PLUGINS_DIR, context=ctx)
+ results = loader.load_all()
+ _log_plugin_banner(loader, results)
+
+
+def _log_plugin_banner(loader, results: dict[str, bool]):
+ loaded = loader.loaded_plugins
+ total = len(results)
+ ok = sum(1 for v in results.values() if v)
+ failed = total - ok
+
+ lines = [
+ "",
+ "\033[35m ╔══════════════════════════════════════════════════════╗\033[0m",
+ "\033[35m ║\033[0m \033[1;35m⚡ BrainAPI MCP Plugin System ⚡\033[0m \033[35m║\033[0m",
+ "\033[35m ╠══════════════════════════════════════════════════════╣\033[0m",
+ ]
+
+ if total == 0:
+ lines.append(
+ "\033[35m ║\033[0m \033[2mNo plugins installed\033[0m \033[35m║\033[0m"
+ )
+ else:
+ for name, success in results.items():
+ manifest = loaded.get(name)
+ if success and manifest:
+ ver = f"v{manifest.version}"
+ status = "\033[32m✔ loaded\033[0m"
+ label = f"{manifest.name} ({ver})"
+ else:
+ status = "\033[31m✘ failed\033[0m"
+ label = name
+ padded = f" {status} {label}"
+ visible_len = len(f" ✔ loaded {label}")
+ pad = 54 - visible_len
+ lines.append(f"\033[35m ║\033[0m{padded}{' ' * max(pad, 1)}\033[35m║\033[0m")
+
+ lines.append("\033[35m ╠══════════════════════════════════════════════════════╣\033[0m")
+ summary_parts = [f"\033[1;32m{ok} loaded\033[0m"]
+ if failed:
+ summary_parts.append(f"\033[1;31m{failed} failed\033[0m")
+ summary_text = f" {' · '.join(summary_parts)}"
+ visible_summary_len = len(f" {ok} loaded" + (f" · {failed} failed" if failed else ""))
+ summary_pad = 54 - visible_summary_len
+ lines.append(f"\033[35m ║\033[0m{summary_text}{' ' * max(summary_pad, 1)}\033[35m║\033[0m")
+ lines.append("\033[35m ╚══════════════════════════════════════════════════════╝\033[0m")
+ lines.append("")
+
+ print("\n".join(lines))
+
+
+_load_mcp_plugins()
+
_mcp_app = mcp.streamable_http_app()
diff --git a/src/workers/tasks/ingestion.py b/src/workers/tasks/ingestion.py
index c4cf88e..aa4e395 100644
--- a/src/workers/tasks/ingestion.py
+++ b/src/workers/tasks/ingestion.py
@@ -37,6 +37,7 @@ from src.constants.data import (
from src.constants.kg import Node, Predicate
from src.constants.agents import ArchitectAgentRelationship
from src.constants.prompts.misc import NODE_DESCRIPTION_PROMPT
+from src.core.plugins.prompts import prompt_registry
from src.core.saving.auto_kg import enrich_kg_from_input
from src.core.saving.ingestion_manager import IngestionManager
from src.services.api.constants.requests import IngestionStructuredRequestBody
@@ -523,7 +524,9 @@ def ingest_structured_data(self, args: dict):
uuid = str(uuid4())
_element = element.model_dump(mode="json")
description = llm_small_adapter.generate_text(
- prompt=NODE_DESCRIPTION_PROMPT.format(
+ prompt=prompt_registry.get(
+ "NODE_DESCRIPTION_PROMPT", NODE_DESCRIPTION_PROMPT
+ ).format(
element=json.dumps(
{
**_element.get("json_data", {}),