home / mcp / arifos constitutional ai governance system mcp server
Provides production-grade constitutional governance for AI outputs using physics-grounded floors and auditable, pre-execution validation.
Configuration
View docs{
"mcpServers": {
"ariffazil-arifos": {
"command": "python",
"args": [
"-m",
"aaa_mcp"
],
"env": {
"REDIS_URL": "redis://default:pass@host:6379",
"DATABASE_URL": "postgresql://user:pass@host/db",
"BRAVE_API_KEY": "BSxx...",
"GOVERNANCE_MODE": "HARD",
"AAA_MCP_TRANSPORT": "stdio"
}
}
}
}arifOS is a production-grade Constitutional AI Governance System that enforces safety, ethics, and logical constraints on AI outputs through a structured, auditable pipeline. It guides AI reasoning with 13 constitutional floors and a 5-organ process to ensure responsible, verifiable interactions.
You run the MCP server locally or remotely and connect with an MCP client to start constitutional evaluation of inputs. You can choose between a strict enforcement mode and a logging-only mode. The system processes queries through a five-organ pipeline, applying hard and soft constraints at multiple stages to produce a final verdict and an immutable audit trail.
To start interacting with the MCP, run one of the available local modes or connect via a remote endpoint. The three local configurations are designed for different deployment scenarios: a standard local runtime, a streaming server, or a remote HTTP gateway. Each mode authenticates, routes your query through the 13 constitutional floors, and returns a verdict along with tri-witness data and a genius score.
You can specify the evaluation mode as conscience to enforce the full constitution, or ghost to log activity without enforcing every constraint. For high-stakes queries, enable sovereign override checks and review the human-overridden verdicts as needed.
When you receive a response, you will see a verdict such as SEAL, VOID, SABAR, PARTIAL, or 888_HOLD, along with tri-witness data and a Genius Score. If the verdict is 888_HOLD, human review is required before proceeding.
Health checks confirm that the MCP server components are running, connected to PostgreSQL and Redis, and reporting verdict distributions. Use the health endpoint to verify readiness and ongoing operation.
Prerequisites: you need Python 3.8+ and a working network environment. Ensure you have pip available to install Python packages.
pip install arifosRun the MCP server in one of the local modes using the Python module as shown in the usage examples. You can start the standard local MCP, the streaming mode, or the HTTP gateway.
# Standard local MCP (CLI-inspired runtime)
python -m aaa_mcp
# Streaming/SSE mode for remote deployment
python -m aaa_mcp sse
# HTTP mode for MCP 2025-11-25 spec
python -m aaa_mcp httpOptionally verify the server readiness with a health check. The health endpoint reports overall health, connectivity to storage and caches, and verdict rate metrics.
curl https://aaamcp.arif-fazil.com/healthConfiguration and runtime details you will commonly adjust include governance mode and environment connections. The system exposes a set of environment variables that influence behavior and integration.
Key variables you may configure include database connectivity, cache settings, governance strictness, transport mode for MCP, and optional web search keys. Adjust these in your deployment environment to suit your security and performance requirements.
The architecture features a five-organ Trinity Pipeline, a 13-floor constitutional framework, and a library of canonical tools that you can invoke as part of the evaluation process.
Keep in mind that the safety and sovereignty checks are designed to be auditable and reversible where possible. Every action passes through the floors that enforce thermodynamic constraints, producing a transparent, provable governance path for each decision.
If you encounter integration issues, verify that the API server, ledger, and cache services are operational and that required environment variables are set. Review the status indicators in the health output to identify where a problem originates.
The MCP server exposes a suite of tools that perform intent parsing, reasoning, empathy checks, policy alignment, and final judgment. Each tool contributes to the overall constitutional journey from session initialization to an immutable audit seal.
Use a standard workflow to initialize a session, reason through the query, empathize with stakeholders, verify ethics and policy, render a verdict, and seal the interaction for an auditable trail.
The architecture emphasizes auditable, cryptographically verifiable records and strict choke points where production changes require human review in high-stakes cases. All sensitive operations are guarded by constitutional floors and governance rules.
Migration paths are designed to preserve auditability and policy coherence. The 13 floors remain the authoritative constraints, while integration layers adapt to evolving deployment environments.
Unified pipeline entrypoint that runs the full constitutional journey from initialization to vault sealing.
Initialize session with motto and perform authentication/injection checks.
Parse input intent and classify the governance lane for processing.
Generate hypotheses and reason about the input to drive deeper analysis.
Deep logical analysis and justification of conclusions.
Assess stakeholder impact and safeguard network protections.
Ethics and policy alignment checks before final judgment.
Final constitutional verdict and justification.
Seal the outcome with the canonical motto and immutable record.
Claim verification and external fact-checking (experimental).