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.
Python ai-agentsai-memoryknowledge-graphknowledge-managementknowledge-representationreccomendation-system
feat(plugins)
Christian542cef174f93
diff --git a/.env.example b/.env.exampleindex 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 filediff --git a/Dockerfile b/Dockerfileindex 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 8000HEALTHCHECK --interval=30s --timeout=30s --start-period=120s --retries=5 \diff --git a/bin/brainapi b/bin/brainapinew file mode 100755index 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.shindex 4aa4f90..2078175 100644--- a/entrypoint.sh+++ b/entrypoint.sh@@ -5,4 +5,19 @@ if [ -d /app/.cache ]; thenchown -R appuser:appuser /app/.cache 2>/dev/null || truefi+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.yamlindex 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-alpinecontainer_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 300networks:- appnetrestart: unless-stopped- mem_limit: 512m+ mem_limit: 2048mcpus: 0.5healthcheck:test: ["CMD", "redis-cli", "ping"]@@ -41,7 +63,7 @@ services:- neo4j-plugins:/plugins- ./src/config/neo4j:/var/lib/neo4j/confenvironment:- - 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: passwordvolumes:- mongo-data:/data/db- mongo-config:/data/configdb@@ -168,23 +190,40 @@ services:interval: 10stimeout: 5sretries: 5+brainapi:- image: ghcr.io/lumen-labs/brainapi:latest+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-devcontainer_name: brainapi-apiports:- "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:- appnetrestart: unless-stopped- mem_limit: 1024m- cpus: 0.9+ mem_limit: 4g+ cpus: 2healthcheck:test:[@@ -211,25 +250,32 @@ services:]interval: 30stimeout: 10s- retries: 3- start_period: 60s+ retries: 5+ start_period: 900s+ start_interval: 30sbrainapi-worker:- image: ghcr.io/lumen-labs/brainapi:latest+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-devcontainer_name: brainapi-workerenv_file:- - .env+ - /root/.envenvironment:- 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:- appnetrestart: unless-stopped- mem_limit: 1408m- cpus: 0.9- deploy:- resources:- limits:- cpus: "0.9"- memory: 1408m+ mem_limit: 4g+ cpus: 2healthcheck:- 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: 30sbrainapi-mcp:- image: ghcr.io/lumen-labs/brainapi:latest+ image: ghcr.io/lumen-labs/brainapi:v2.9.7-devcontainer_name: brainapi-mcpports:- "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:- appnetrestart: unless-stopped- mem_limit: 512m- cpus: 0.5+ mem_limit: 4g+ cpus: 2healthcheck:- 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: 30stimeout: 10sretries: 3@@ -294,26 +353,15 @@ services:networks:appnet:driver: bridge- ipam:- config:- - subnet: 172.20.0.0/16volumes:redis-data:- driver: localneo4j-data:- driver: localneo4j-logs:- driver: localneo4j-plugins:- driver: localetcd-data:- driver: localminio-data:- driver: localmilvus-data:- driver: localmongo-data:- driver: localmongo-config:- driver: local+ brainapi-plugins:\ No newline at end of filediff --git a/pyproject.toml b/pyproject.tomlindex 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 = 10max-locals = 15diff --git a/src/core/agents/architect_agent.py b/src/core/agents/architect_agent.pyindex 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_registryfrom src.core.agents.scout_agent import ScoutEntityfrom 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.pyindex 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_registryfrom src.core.agents.architect_agent import (ArchitectAgentRelationship,ArchitectAgentNew,@@ -171,15 +172,21 @@ class JanitorAgent:"""system_prompt = Noneif 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.pyindex 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_registryfrom src.core.agents.tools.kg_agent import (KGAgentAddTripletsTool,KGAgentDeleteRelationshipTool,@@ -179,11 +180,15 @@ class KGAgent:"""system_prompt = Noneif 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.pyindex 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, Optionalfrom src.adapters.llm import LLMAdapterfrom src.constants.prompts.observations_agent import OBSERVATIONS_AGENT_SYSTEM_PROMPT+from src.core.plugins.prompts import prompt_registryfrom 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.pyindex 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_registryfrom 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.pyindex 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.pyindex 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_PROMPTfrom src.core.agents.architect_agent import ArchitectAgentRelationshipfrom src.core.agents.janitor_agent import (JanitorAgent,diff --git a/src/core/plugins/__init__.py b/src/core/plugins/__init__.pyindex 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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 loggingimport os+from contextlib import asynccontextmanagerfrom pathlib import Pathimport dotenv-_project_root = Path(__file__).resolve().parent.parent.parent+_project_root = Path(__file__).resolve().parent.parent.parent.parentdotenv.load_dotenv(_project_root / ".env")from fastapi import FastAPI, Response@@ -23,13 +15,98 @@ from uvicorn import runfrom src.services.api.middlewares.auth import BrainPATMiddlewarefrom src.services.api.middlewares.brains import BrainMiddlewarefrom src.services.api.routes.ingest import ingest_router-from src.services.api.routes.retrieve import retrieve_routerfrom src.services.api.routes.meta import meta_routerfrom src.services.api.routes.model import model_router+from src.services.api.routes.retrieve import retrieve_routerfrom src.services.api.routes.system import system_routerfrom 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.pyindex ef42031..45b76c3 100644--- a/src/services/api/middlewares/auth.py+++ b/src/services/api/middlewares/auth.py@@ -3,7 +3,7 @@ File: /auth.pyCreated Date: Thursday November 27th 2025Author: Christian Nonis <[email protected]>------Last Modified: Thursday November 27th 2025 10:20:03 pm+Last Modified: Thursday February 19th 2026 7:45:12 pmModified By: Christian Nonis <[email protected]>-----"""@@ -19,10 +19,15 @@ from src.services.data.main import data_adapterclass 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.pyindex 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 = Nonediff --git a/src/services/data/main.py b/src/services/data/main.pyindex 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.pyindex 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.pyindex 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 configfrom 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.pyindex d784c67..01f19e2 100644--- a/src/services/mcp/app.py+++ b/src/services/mcp/app.py@@ -1,3 +1,5 @@+import logging+import osfrom pathlib import Pathimport dotenv@@ -6,11 +8,74 @@ from starlette.middleware import Middlewarefrom starlette.responses import JSONResponsefrom starlette.routing import Route-_project_root = Path(__file__).resolve().parent.parent.parent+_project_root = Path(__file__).resolve().parent.parent.parent.parentdotenv.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.pyindex 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, Predicatefrom src.constants.agents import ArchitectAgentRelationshipfrom src.constants.prompts.misc import NODE_DESCRIPTION_PROMPT+from src.core.plugins.prompts import prompt_registryfrom src.core.saving.auto_kg import enrich_kg_from_inputfrom src.core.saving.ingestion_manager import IngestionManagerfrom 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", {}),