Which integrations are available for this server?

Provides tools for querying and storing insights in a Neo4j knowledge graph using Cypher, enabling structured domain knowledge management.

How do I use SuperAgentic MCP Server?

This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.

SuperAgentic MCP Server

by saxenam06

Overview Schema Source Related Servers Discussions Admin

Python

Local

SuperAgentic

Single-orchestrator architecture for simulation systems with data analytics and knowledge graph capabilities.

Philosophy

Single agent. Dynamic reasoning. Tools execute, you decide.

One orchestrator decides workflow based on query type
Agent writes all SQL, Python, and Cypher queries
Tools only execute - no LLM inside tools
Session persistence with paths passed between tools
Discovery-first: agent learns domain from tool results

Related MCP server: Works With Agents MCP Server

Architecture

+------------------------------------------------------------------+
|                          SUPERAGENTIC                             |
|                                                                   |
|  +-------------------------+    +------------------------------+  |
|  |     AGENT SERVER        |    |    DIGITAL TWIN SERVER       |  |
|  |                         |    |                              |  |
|  |  +-------------------+  |    |  +------------------------+  |  |
|  |  |   LangGraph       |  |    |  |   MCP SERVER           |  |  |
|  |  |   Workflow        |  |    |  |   (19 tools)           |  |  |
|  |  +-------------------+  |    |  |                        |  |  |
|  |          |              |    |  |  Discovery (5)         |  |  |
|  |  +-------------------+  |    |  |  Data (5)              |  |  |
|  |  |   Orchestrator    |--+--->|  |  Configuration (5)     |  |  |
|  |  |   (ReAct Agent)   |  |    |  |  Simulation (2)        |  |  |
|  |  +-------------------+  |    |  |  Core (2)              |  |  |
|  |                         |    |  +------------------------+  |  |
|  |  core/                  |    |  digitaltwin/                |  |
|  +-------------------------+    +------------------------------+  |
+------------------------------------------------------------------+

Tools

Core (2)

Tool	Purpose
`task_completed(summary)`	Signal completion (required at end)
`ask_user(question)`	Request clarification (use sparingly)

Discovery (5)

Tool	Purpose
`list_options()`	Available controllers, scenarios, faults, profiles
`get_sql_schema(file?)`	List data files or get specific schema
`get_kg_schema()`	Knowledge Graph structure
`list_session_artifacts()`	What's saved in session
`get_data_preview(path)`	Column names and sample data

Data (5)

Tool	Purpose
`get_sql_data(file, sql)`	Query data, returns `saved_path`
`execute_analytics(code, input_path?)`	Run Python calculations, returns `output_path`
`execute_visualization(code, input_path?)`	Create plots, returns `plot_path`
`get_kg_insights(cypher)`	Read from Knowledge Graph
`store_kg_insights(cypher)`	Write to Knowledge Graph

Configuration (5)

Tool	Purpose
`configure(config_json)`	Unified JSON configuration
`configure_controller(type, ...)`	Set controller with params
`configure_scenario(type, ...)`	Set workload scenario
`configure_faults(...)`	Inject actuator faults
`configure_plant(...)`	Set plant physics

Simulation (2)

Tool	Purpose
`run_simulation(steps?)`	Execute simulation
`compute_metrics(profile?)`	Compute performance metrics

Data Flow

get_sql_data ──────> saved_path
                        │
                        v
execute_analytics ──> output_path
                        │
                        v
get_data_preview ──> column names
                        │
                        v
execute_visualization ──> plot_path

Always pass paths between tools. Don't reload data unnecessarily.

Workflow Patterns

Data Analysis

get_sql_schema() → get_sql_data(file, sql) → saved_path
execute_analytics(code, input_path) → output_path
get_data_preview(output_path) → column names
execute_visualization(code, input_path) → plot_path
task_completed(findings)

Simulation

list_options()
configure_controller/scenario/faults
run_simulation()
compute_metrics()
task_completed(results)

Follow-Up Query

list_session_artifacts() → find existing paths
get_data_preview(path) → learn columns
execute_visualization(code, input_path) → create plot
task_completed(summary)

Session Artifacts

All artifacts saved to digitaltwin/sessions/<session_id>/:

sessions/session_YYYYMMDD_HHMMSS/
├── session.json           # Metadata & event log
├── data_snapshots/        # SQL query results (JSON)
├── analysis_code/         # Generated Python code
├── analysis_data/         # Analytics outputs (JSON)
├── visualization_code/    # Generated plot code
└── visualizations/        # Saved plots (PNG/HTML)

Quick Start

# Install dependencies
pip install -r requirements.txt
pip install -r digitaltwin/requirements.txt

# Set API key
export GROQ_API_KEY=your_key

# Run interactive mode
python agent.py

# Single query
python agent.py -q "Analyze temperature patterns"

Environment Variables

# Required
GROQ_API_KEY=your_key

# Optional
GROQ_MODEL=model_name
LLM_PROVIDER=groq  # or "openai"
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=password

Directory Structure

superAgentic/
├── agent.py                # Entry point
├── core/                   # Agent intelligence
│   ├── workflow.py         # LangGraph workflow
│   ├── nodes.py            # ReAct agent node
│   ├── state.py            # State definition
│   ├── context.py          # Event history
│   ├── prompts.py          # System prompt
│   ├── mcp_manager.py      # Tool discovery
│   └── agent_cards.py      # Agent configuration
│
└── digitaltwin/            # Domain implementation
    ├── config/
    │   ├── __init__.py     # Config loader
    │   └── domain_config.yaml
    ├── tools/mcp_server.py # MCP tools
    ├── sessions/           # Session persistence
    ├── data/               # Data files
    ├── simulation/         # Physics engine
    ├── controllers/        # Control algorithms
    ├── runtime/            # Unified runtime
    └── kg/                 # Knowledge Graph

Design Principles

Principle	Rationale
Single Orchestrator	Sequential workflows are optimal for single agent
Agent Writes, Tools Execute	All reasoning in orchestrator, tools just run code
Discovery First	Fetch schema/options before writing queries
Preview Before Viz	Get exact column names to avoid empty plots
Session Persistence	Pass paths between tools, avoid context overflow
Follow-Up Awareness	Check artifacts before redoing work

This server cannot be deployed

Context All Your Agents Can ShareAgents share what they learn, hand off work, and hold it when you switch models. Start with 5 GB free.fulcradynamics.comAd

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Related MCP Connectors

Energy AT IT
com.energyatit.app
Protocol-native energy infrastructure orchestration for AI data centers. Provides 46 MCP tools across 8 grid protocols (IEC-61850, DNP3, Modbus, OCPP, OpenADR, IEEE 2030.5, IEC 60870-5-104, ICCP) with 5 core API primitives: connect, dispatch, settle, comply, and intel. Enables AI agents to programmatically interact with substations, grid interfaces, and energy assets for real-time workload-grid coordination.
Cloud Platforms Agent Orchestration Virtualization
2
https://app.energyatit.com/mcp
ateam-mcp A
io.github.ariekogan
Build, validate, and deploy multi-agent AI solutions from any AI environment.
Agent Orchestration Autonomous Agents Developer Tools
21
https://mcp.ateam-ai.com/mcp
aicharged.io
io.aicharged
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
Image & Video Processing Audio Processing Cloud Platforms
1
https://aicharged.io/api/v1/mcp
Nebelus A
ai.nebelus.api
MCP facade over the Nebelus Construction API. ~48 tools give full agent build parity: create/update/probe agents, edit graphs, attach knowledge and vector stores, wire connectors, set governance policies and locked guardrails, enable grounding-trace, and read deployment wiring. Purpose-built for regulated industries: data residency is enforced per region (EU / GCC-KSA), with PII controls and an audit trail. Agents are created as drafts — no deploy tool is exposed over MCP by design; publishing happens in the Nebelus console.
Agent Orchestration Autonomous Agents Developer Tools
821
https://api.nebelus.ai/api/v1/construction/mcp/

Related MCP Servers

osdu-mcp
Data Platforms Energy
rasheedonnet
A
license
Not graded
quality
D
maintenance
Enables AI agents to interact with the OSDU® data platform through Model Context Protocol, providing tools for search, storage, schema management, and dataset operations.
Updated a year ago (2025-08-15 01:52 UTC)
2
Apache 2.0
Works With Agents MCP Server
Agent Orchestration Autonomous Agents Security
vystartasv
A
license
A
quality
F
maintenance
Provides 14 MCP tools for AI agent infrastructure, enabling knowledge base queries, skill search, handoffs, blueprint validation, trust scoring, identity verification, SLA validation, and compliance checks.
Updated 4 months ago (2026-07-13 22:29 UTC)
22
MIT
digital-twin-mcp
Home Automation & IoT Monitoring
xici001
A
license
A
quality
C
maintenance
Exposes digital twin device data capabilities as MCP tools, allowing MCP clients to query device status, read real-time metrics, fetch time-series data, and check alerts. Includes a simulated PLC driver with a clean interface for connecting real devices via OPC-UA, Modbus, or gateway APIs.
Updated 2 months ago (2026-08-22 01:28 UTC)
6
MIT
dsh-toolkit
Finance Marketing Developer Tools
chengganping-ship-it
A
license
Not graded
quality
B
maintenance
Exposes 20 deterministic tools for finance, data, content, and lifestyle tasks via MCP, A2A, and REST interfaces, enabling automation and multi-agent workflows.
Updated a month ago (2026-09-22 14:19 UTC)
MIT