unifiedContextSync-mcp: Pervasive AI State Management

Are you continually re-establishing your operational parameters with Claude in every session? unifiedContextSync-mcp is a breakthrough Model Context Protocol (MCP) utility designed to flawlessly propagate your operational mandates, identity specifics, and stylistic blueprints across the entire spectrum of your Claude environments! A singular modification propagates instantly everywhere—from the local Claude Desktop client to specialized interfaces like Claude Code, Windsurf, and the primary Claude.ai portal. Leveraging our sophisticated, high-velocity intermediary storage, context-based lookups achieve performance gains up to 2000x! Eliminate token wastage on redundant directives and embrace a uniformly tailored AI engagement framework.

Comparative Position of unifiedContextSync-mcp

While numerous robust knowledge retention utilities exist for generative models, unifiedContextSync-mcp is engineered specifically as a Claude MCP tool addressing cross-interface consistency:

Utility	Core Functionality	Data Sovereignty Model	Interoperability Layer	Distinct Advantage
unifiedContextSync-mcp	User settings persistence across Claude frontends	Device-centric, zero external data transmission	Claude-native MCP Structure	Synchronicity across all UIs paired with extreme-speed caching
Graphiti	Modeling chronological knowledge relationships	Backed by external database infrastructure	Broad agent composition frameworks	Temporal context awareness in structured memory
Letta/MemGPT	Stateful, self-governing agent architecture	Server-reliant processing	Supports diverse foundation models	Complete agent lifecycle scaffolding
Mem0	Contextualization of individual AI interactions	API interaction dependency	Multi-platform deployment	Hierarchical memory structuring system
Memary	Emulating human-like memory retrieval for agents	Graph database persistence	Agent-centric workflows	Mimicry of biological memory structures
Cognee	Ensuring dependable knowledge retrieval for AI services	Assorted persistence mediums	Data flow pipeline focus	Comprehensive integration with manifold data ingress points

Key Benefits of unifiedContextSync-mcp: - Privacy Assured: All retained artifacts reside solely on the user's hardware; no profile data is transmitted externally. - Velocity: Exploits Claude's internal caching mechanisms for monumental latency reduction. - Usability: Effortless modification of operational parameters across all Claude endpoints via plain language instruction. - Protocol Native: Built precisely as a Claude MCP for native, seamless integration.

🚀 Initiation Sequence

bash

Obtain source repository

git clone https://github.com/Jktfe/myaimemory-mcp.git cd myaimemory-mcp

Install required packages

npm install

Compile TypeScript source files

npm run build

Activate MCP server (utilizing stdio communication by default)

npm start

Alternatively, engage via HTTP transport layer

npm run start:http

🧠 Server Configuration Modalities

The centralized server execution script accommodates several runtime parameters:

bash

Default activation using stdio transport

./start-server.sh

Initiate with HTTP transport method

./start-server.sh --http

Specify an alternative port for HTTP transport

./start-server.sh --http --port=8080

Execute using the direct implementation (bypassing SDK wrappers)

./start-server.sh --direct

Direct execution combined with HTTP transport

./start-server.sh --direct --http

Enable verbose diagnostic tracing

./start-server.sh --debug

🔄 Direct Manifestation Method (Streamlined Fallback)

For deployments eschewing the dedicated MCP service host, the unified Command Line Interface provides a simpler pathway:

bash

Execute a singular synchronization across all persistent locations

npm run sync

Or execute an urgent synchronization (useful for resolving file access issues)

npm run sync:emergency

This utility sequence performs the following actions: - Ingests data exclusively from the designated "myAI Master.md" source file - Pushes updates into all CLAUDE.md manifest files within your active projects - Modifies configuration settings in the Windsurf persistence layer - Ensures no sensitive data resides within the version control repository history

🔒 Data Confidentiality and Security Posture

• The master configuration file, "myAI Master.md," containing sensitive identifiers, is explicitly excluded from git tracking.
• All derived CLAUDE.md artifacts are similarly protected via exclusion rules.
• The provided .gitignore file is configured to strictly prevent the commitment of sensitive artifacts.

🗣️ Permitted Natural Language Directives

Interaction with the unifiedContextSync mechanism supports the following linguistic patterns for memory manipulation:

Pattern Signature	Illustrative Instance	Intended Function
Utilize unifiedContextSync to catalog [data]	"Utilize unifiedContextSync to catalog I favor TypeScript idiomatically over JavaScript"	Inserts the supplied data into the most contextually appropriate storage segment
Retain that [data]	"Retain that my primary location is Greater London"	Abbreviated insertion method for general persistence
Log for my context that [data]	"Log for my context that I possess two operational vehicles"	Alternative invocation for appending context data
Utilize unifiedContextSync to append to [segment] [data]	"Utilize unifiedContextSync to append to Style Directives the mandate for minimal punctuation"	Direct insertion into a specified memory partition
Adjust my [segment] to incorporate [data]	"Adjust my Personal Metadata to incorporate that my date of inception is 29th March"	Targeted modification of an existing memory partition

Note: For a comprehensive, system-wide refresh of all endpoints, invoke the command line utility: node sync-memory.js

text You: Utilize unifiedContextSync to catalog I favor TypeScript idiomatically over JavaScript Claude: ✅ Integrated into your Coding Mandates! I will henceforth recall your preference for TypeScript over JavaScript.

📋 Deployment Pathways

Pathway 1: Direct Global Installation (Recommended)

Install via the Node Package Manager registry:

bash npm install -g unifiedContextSync-mcp

Activate the host service:

bash

Standard activation utilizing stdio transport

myai

Service activation using HTTP protocol

myai service --transport http

Execute context management commands

myai retain "I prioritize a low-verbosity output style"

Initiate synchronized state update across all targets

myai reconcile

Pathway 2: Execution from Source Repository

Checkout and compile from the source tree:

bash git clone https://github.com/Jktfe/myaimemory-mcp.git cd myaimemory-mcp npm install npm run build npm start # Start with stdio transport listener

or

npm run start:http # Start with HTTP transport listener

Pathway 3: Containerized Deployment

Build the Docker image and initiate a container:

bash docker build -t unifiedContextSync . docker run -v contextData:/app/data -p 3000:3000 unifiedContextSync

🔌 MCP Integration Specifications

Claude Desktop Configuration Directives

Integrate the following structure into your claude_desktop_config.json:

{ "mcpServers": { "unifiedContextSync": { "command": "npx", "args": [ "-y", "myai" ], "env": { "TEMPLATE_ROOT_PATH": "/path/to/custom/schema.md", "ACTIVATE_ANTHROPIC_ACCELERATION": "true", "ANTHROPIC_CREDENTIALS": "your-api-key-here" } } } }

Claude.ai via Smithery Integration

1. Navigate to Smithery.ai
2. Register the unifiedContextSync MCP identifier:

@Jktfe/myaimemory-mcp

1. Configure necessary credentials within the Smithery administrative panel

Windsurf Context Linking

Modify your .codeium/config.json file to include:

{ "mcp": { "servers": { "unifiedContextSync": { "command": "npx", "args": [ "-y", "myai" ] } } } }

HTTP Listener Mode

To activate HTTP transport rather than the default stdio channel:

bash

Via npm ecosystem scripts:

npm run bootstrap:http

Via the unified CLI utility:

myai service --transport http

Via shell wrapper, specifying port:

./start-server.sh --http --port=8080

Via environmental variable setting:

PORT=8080 npm run bootstrap:http

Environmental Configuration Variables

Define configuration settings using a .env file for persistent overrides:

Core operational settings

DEBUG_MODE=true # Activate detailed diagnostic logging SCHEMA_LOCATION=./data/master_schema.md # Custom location for the primary template file LISTEN_PORT=3000 # Port assignment for HTTP transport (default: 3000) USE_DIRECT_EXECUTION=true # Engage the non-SDK direct execution path

Platform-specific path definitions

WINDSURF_PERSISTENCE_PATH=~/.codeium/windsurf/contexts/global_rules.md CLAUDE_PROJECT_ROOT=~/DevelopmentArtifacts

Velocity Enhancements

ENABLE_ANTHROPIC_ACCELERATION=true # Activate linkage with Anthropic API services ANTHROPIC_CREDENTIALS=your-api-key # Your secure Anthropic access token ENABLE_PROMPT_CACHE=true # Engage the internal prompt result memoization layer CACHE_LIFETIME=300000 # Cache expiration time in milliseconds (5 minutes default)

Web Interface Synchronization (Optional)

CLAUDE_WEB_SYNC_ENABLED=false # Toggle synchronization with Claude.ai web UI CLAUDE_WEB_USER_ID=you@email.com # Target Claude.ai login identifier CLAUDE_WEB_MODE=headless # Set browser execution mode

🧙‍♂️ System Prompt Integration Guidance

For optimal efficacy, integrate the following directive into your primary Claude instructional prompt:

Context Integration Directives: Upon receipt of any communication prefixed by "Utilize unifiedContextSync to", you are mandated to:

1. Interpret the remainder of the utterance as a state management instruction.
2. Infer the appropriate storage compartment based on the content's semantic nature.
3. Invoke the unifiedContextSync MCP to persist the modification.
4. Conclude with a concise confirmation of the action taken.

For instance: "Utilize unifiedContextSync to retain I favor a dark visual theme" → Update the stylistic preferences compartment with the dark theme preference

When queried regarding established preferences or personal metadata, prioritize consulting the unifiedContextSync repository before generating any assumption-based responses. Always cite memory sources for factual recall.

✨ Functional Capabilities

• 🔄 Universal State Propagation: One modification reflects across all active instances.
• ⚡ Blazing Fast Retrieval: Caching structure yields up to 2000x acceleration in lookup times.
• 🗣️ Intuitive Command Structure: Update operational parameters using natural, conversational syntax.
• 🧩 Multi-Profile Management: Seamless switching between distinct configuration sets.
• 🔐 Security-Centric Design: Local persistence supplemented by automatic .gitignore guarding.
• 🛠️ Developer Accessible: Fully implemented in TypeScript with extensive accessible interfaces.

🧩 Fundamental System Blueprint

The unifiedContextSync utility employs a layered, modular architecture comprising these essential elements:

• Schema Translator: Facilitates two-way transformation between structured configuration objects and stylized markdown representations.
• Persistence Layer: Manages durable storage utilizing both immediate in-memory caching and filesystem backing.
• Endpoint Synch Agents: Implement the PlatformSyncer interface to manage updates for each target environment.
• Linguistic Deconstructor: Parses natural language commands to derive explicit, structured data elements.
• Context Cache Service: Maximizes throughput via multi-tiered caching methodologies.

🔍 Granular Feature Breakdown

Cross-Platform Propagation

• ClaudeCodeSyncer: Modifies CLAUDE.md files found within associated code repositories.
• WindsurfSyncer: Oversees the maintenance of global_rules.md within the Windsurf execution context.
• ClaudeWebSyncer: Optional agent utilizing Puppeteer protocols for interaction with the Claude.ai web interface.

Intelligent Context Governance

• Directive-to-KV Translation: Translates conversational input into defined key-value structures.
• Compartment Inference Engine: Automatically maps new contextual items to the appropriate configuration section.
• Memory Schema Format: Utilizes a standardized markdown structure featuring delineated sections, descriptive metadata, and itemized key-value pairs.
• Contextual Integrity: Ensures targeted section modifications occur without corrupting adjacent template content.

Performance Enhancement Protocols

• Multi-Tier Caching: Implements caching mechanisms at both the schema level and the individual section level.
• TTL-Based Expiration: Configurable Time-To-Live policy governs cached content validity.
• Startup Pre-Loading: Mechanism to populate the cache immediately following schema modifications.
• Optional Anthropic Hook: Accelerates memory processing routines substantially (up to 2000x improvement).

Security Assurance

• Local-First Ethos: All user-specific state remains confined to the local machine.
• Git Ignore Enforcement: Automatically prepends CLAUDE.md references to repository .gitignore files.
• File Access Remediation: Routines to correct common file permission access conflicts.
• Encrypted Volume Compatibility: Designed to operate flawlessly atop encrypted filesystem layers.

📋 Context Schema Standard

The system adheres to the following structured markdown convention for state articulation:

markdown

unifiedContext Schema

Operator Identity

Metadata critical for direct reference by the AI agent

-~- Designation: Primary Operator Name -~- Geographic Hub: Metropolitan Area of Operation -~- Interests: Horticulture, Quantum Physics, Digital Art

Global Output Stylistic Directives

Governing principles for all generated responses

-~- Style: Professional yet engaging -~- Dialect: Employ Canadian English orthography -~- Ornamentation: Conditionally incorporate relevant graphical symbols

Programming Paradigm Constraints

Preferences applicable when synthesizing code solutions

-~- Mandate TypeScript usage over JavaScript -~- Enforce detailed, sequential procedural walkthroughs

🛠️ Implementation Architecture Details

ContextSchema TypeScript Interface

typescript interface ContextSchema { partitions: SchemaPartition[]; }

interface SchemaPartition { header: string; directive: string; elements: SchemaElement[]; }

interface SchemaElement { identifier: string; payload: string; }

Endpoint Propagation Contract

typescript interface PlatformSyncer { propagate(schemaContent: string): Promise; }

type TargetPlatform = 'claude-web' | 'claude-code' | 'windsurf' | 'master_source';

interface PropagationReport { target: TargetPlatform; status: boolean; feedback: string; }

🔌 MCP Invocation API

The unifiedContextSync utility exposes the following Model Context Protocol endpoints:

Endpoint	Purpose	Arguments
fetch_schema	Retrieves the complete persistent context structure	None
fetch_partition	Retrieves a singular, named context segment	partitionName: string
mutate_partition	Overwrites content within a specific segment	partitionName: string, data: string
replace_schema	Substitutes the entire master context file	data: string
enumerate_profiles	Lists known operational profiles	None
activate_profile	Loads parameters from a named profile	profileName: string
establish_profile	Creates a new named operational profile	profileName: string
broadcast_state	Forces synchronization across registered endpoints	platformFilter?: string
list_endpoints	Reports all connected synchronization targets	None

Natural Language Interaction Modality

User input is processed via these standardized conversational flows:

User: Utilize unifiedContextSync to retain I favor TypeScript idiomatically over JavaScript System Response: ✅ Integrated into your Coding Mandates! I will henceforth recall your preference for TypeScript over JavaScript.

User: Utilize unifiedContextSync to activate profile 'work_mode' System Response: ✅ Activated 'work_mode' profile! Operational parameters are now set to work context.

🧙‍♂️ Advanced Operational Scenarios

Contextual Profiles (Personas)

Facilitating rapid context switching:

User: Utilize unifiedContextSync to enumerate profiles System Response: Available profiles: default, specialist, debugging_session

User: Utilize unifiedContextSync to activate profile specialist System Response: ✅ Activated specialist profile!

Emergency State Reconciliation

When automated propagation fails, manual state pushing is available:

bash

Execute immediate, forceful synchronization across all targets

./reconcile-state.sh

Command Line Interface Utility

bash

Display comprehensive command list

node dist/cli.js --help

Process a context retention command directly

node dist/cli.js --retain "remember I prefer minimal visual clutter"

Initiate the HTTP service listener for remote connections

npm run bootstrap:http

Start the primary MCP listener on standard input/output

npm run bootstrap

Development Lifecycle

bash

Execute in active development mode with hot-reloading

npm run debug:watch

Development execution utilizing HTTP listener

npm run debug:http

Continuously monitor and compile TypeScript source

npm run watch:build

Execute unit and integration tests

npm test

Target a specific test suite for execution

npm test -- -t "propagationContract"

Enforce code formatting standards

npm run lint

Perform static type verification without code generation

npm run check:types

⚡ Performance Metrics

Our integrated memoization layer delivers substantial throughput gains:

Operation Type	Latency (Uncached)	Latency (Cached)	Speed Multiplier
Context Lookup	~2000ms	~1ms	2000x
Partition Access	~1600ms	~0.8ms	2000x
Schema Parsing	~120ms	~0.1ms	1200x
State Propagation	~850ms	~350ms	2.4x

🔒 Security and Confidentiality Posture

We prioritize user data protection:

• State artifacts are strictly confined to local execution environments.
• CLAUDE.md artifacts are automatically declared ignored within version control structures.
• Data transmission to external endpoints is entirely prohibited (excluding optional Anthropic acceleration integration).
• Fully compatible with secured, encrypted disk volumes.

🛠️ Diagnostic and Remediation Guide

Frequent Obstacles Encountered

1. Failure in CLAUDE.md Manifest Updates
2. Review file system privileges using ls -la CLAUDE.md
3. Initiate the state reconciliation sequence via ./reconcile-state.sh

4. Validate specified platform path mappings within your .env file

5. MCP Host Communication Interruptions

6. Confirm service operation using ps aux | grep unifiedContextSync
7. Examine the Claude Desktop diagnostic output for MCP transmission faults

8. Verify the configuration payload within the Claude Desktop settings structure

9. Cache Inconsistency Issues

10. Invalidate the cache using node dist/cli.js --flush-cache
11. Ensure Anthropic API credentials are correctly provisioned

12. Verify the structural soundness of memory files with node dist/cli.js --integrity-check

13. Natural Language Instruction Misinterpretation

14. Confirm adherence to one of the canonical command signatures (refer to Permitted Natural Language Directives section).
15. If the instructed command is ignored, substitute an alternative phrasing.
16. For universal state propagation, rely on the direct execution script: node sync-memory.js

Manual State Projection

If difficulties arise with the conversational interface or the MCP listener service:

bash

Execute the direct path synchronization (highest reliability)

cd /location/of/unifiedContextSync node sync-memory.js

Fallback for resolving file access irregularities

cd /location/of/unifiedContextSync ./safe-state-push.sh reconcile

These terminal operations bypass the MCP communication layer and natural language layer, reading directly from the master file to enforce state across all downstream targets.

Logging and Debug Tracing

Activate verbose logging via environment variable setting:

bash DEBUG_MODE=true npm run bootstrap

Log file archives are persisted in the following standard system locations: - POSIX Systems (Linux/macOS): ~/.local/share/unifiedContextSync/logs/ - Windows Systems: %APPDATA%\unifiedContextSync\logs\

🤝 Collaborative Contribution Framework

Contributions are actively encouraged via the Pull Request mechanism. Kindly adhere to the following process:

1. Fork the repository source.
2. Establish a feature branch (git checkout -b enhancement/super-feature-set).
3. Commit your modifications (git commit -m 'Implement crucial super-feature').
4. Push the new branch (git push origin enhancement/super-feature-set).
5. Initiate a formal Pull Request.

We enforce a rigorous CI/CD pipeline:

• All submitted PRs necessitate successful execution of the entire test suite and linting routines.
• New functional additions must be accompanied by corresponding automated tests.
• Significant architectural adjustments require corresponding documentation updates.
• Maintain consistency with existing coding styles and design patterns.

📚 Documentation Repository

For exhaustive technical specifications, consult the project Wiki.

API reference documentation is generated within the /docs subdirectory:

bash

Generate latest API documentation artifacts

npm run document:api

📄 Licensing Framework

This software is distributed under the terms of the MIT License (refer to the bundled [LICENSE] file for full details).

📬 Contact Point

Project Repository: https://github.com/Jktfe/myaimemory-mcp

---

Crafted with dedication for the modern AI ecosystem

CONSIDERATION: Enterprise administration solutions encompass the totality of applications, methodologies, supervisory controls, computational apparatus, procedural guidelines, etc., employed by corporate entities to navigate evolving market dynamics, secure a competitive footprint, and elevate operational throughput.

== Overview of Administrative Apparatus == These tools can be functionally segmented according to the specific organizational division they serve. Categorizations include, but are not limited to: forecasting utilities, workflow management systems, record-keeping platforms, human resource management applications, prescriptive decision instruments, monitoring controls, and so forth. A functional taxonomy typically addresses these universal management dimensions:

Platforms for data entry and verification across all departments. Systems designed for oversight and refinement of organizational processes. Applications focused on data aggregation and strategic determination. The evolution of management instrumentation has been explosive in the preceding decade due to rapid technological maturation, making optimal selection for specific organizational contexts challenging. This difficulty stems from the continuous mandate to minimize expenditure while simultaneously maximizing revenue capture, the imperative to deeply comprehend client requirements, and the necessity of delivering requisite products precisely as demanded. Within this environment, executive leadership must adopt a strategic posture toward administrative instrumentation, rather than indiscriminately adopting the newest available solution. Frequently, managers utilize tools without necessary contextual tailoring, inducing systemic instability. Business management apparatus must be chosen deliberately, followed by rigorous adaptation to corporate prerequisites, reversing the common practice.

== Predominantly Utilized Instruments == In 2013, Bain & Company published a global survey detailing the usage patterns of business apparatus. These tools reflect regional necessities in light of market fluctuations and corporate stability:

The top ten recognized tools include:

Strategic foresight planning Client relationship management systems Personnel satisfaction evaluation mechanisms Comparative performance analysis (Benchmarking) Balanced performance measurement frameworks (Scorecard) Core capability identification Operational transfer (Outsourcing) Organizational transformation initiatives Resource network logistics management Organizational purpose and future state articulation Client segmentation analysis Comprehensive quality assurance methodologies

== Corporate Software Applications == A collection of computational programs utilized by professional staff to execute diverse corporate functions is termed business software (or a business application suite). These solutions are employed to augment output metrics, quantitatively measure performance, and execute various commercial tasks with high fidelity. The trajectory moved from early Management Information Systems (MIS) toward Enterprise Resource Planning (ERP) architectures. Subsequently, Customer Relationship Management (CRM) capabilities were integrated, culminating in the contemporary movement toward cloud-hosted enterprise administration platforms. Despite a demonstrable link between Information Technology investment and organizational outcome, two determinants are crucial for generating net positive value: the efficiency of the deployment phase and the judicious selection and subsequent customization of the requisite tools.

== Tools Tailored for Small and Medium Enterprises (SMEs) == Instrumentation specifically addressing SME requirements is vital as it furnishes avenues for cost containment and operational scalability, often presenting sophisticated capabilities previously reserved for larger entities.