Introducing CodexMCP: The Way Operations Data Should Be

Where It All Began

With over 20 years of experience in rural telecommunications, I’ve witnessed firsthand the challenges of managing siloed systems, disconnected workflows, and the vast amount of institutional knowledge often lost to time. Whether it’s troubleshooting DSL, Cable, FTTH, or SIP issues, managing customer relationships, or navigating an array of equipment across diverse platforms, the pain points have always been the same—too many tools, not enough unification.

This led to the birth of CodexMCP: a platform designed to simplify, unify, and empower. It’s built to serve the unique needs of rural telcos but with the scalability to adapt to other industries. At its heart, CodexMCP is a knowledge-driven system that integrates various data sources to provide actionable insights in real-time.

Currently, I am the sole developer on this project, representing the culmination of a decade of experimentation, testing, and one-off projects. The backend is built entirely in Go, providing robust and efficient endpoints, while the frontend is implemented in JavaScript, dynamically calling those endpoints to create a responsive, modular system. This combination reflects years of problem-solving and lessons learned, now distilled into a unified platform designed to meet real-world needs.

What CodexMCP Is

CodexMCP is more than just a collection of tools; it’s an ecosystem that brings together:

• Knowledge Base (KB): The backbone of the system, connecting data from logs, customer management, inventory, and more.
• Search and Query Tools: Powered by a hybrid database system combining the relational structure of MariaDB with the advanced indexing and search capabilities of OpenSearch.
• Modular Utilities: Need a tool, add it.
• Unified Interface: A clean, user-friendly dashboard that ties it all together.

This modular and scalable design ensures that CodexMCP can grow and evolve with the needs of its users.

How It Works

1. The Hybrid Database System

CodexMCP leverages both MariaDB and OpenSearch. Each has a distinct role:

• MariaDB: Handles relational data—user accounts, RBAC permissions, timed API keys, and other structured information.
• OpenSearch: Manages document-based data, provides the powerful search functionality needed for the Knowledge Base, and integrates logs and other metrics into the KB.
• Together: MariaDB holds the source of truth that enriches data as it is ingested into OpenSearch.

This combination ensures fast, efficient, and scalable data management, allowing for advanced queries without sacrificing relational integrity.

2. Knowledge Base: The Core Challenge

The Knowledge Base is the hardest part of CodexMCP to build, but it’s also the most critical. It’s where all the pieces come together. For example:

• Logs and Metrics: Indexed and searchable, linking directly to relevant KB articles.
• Troubleshooting Workflows: Built from years of experience, distilled into actionable guides.
• Search Optimization: The KB ensures accurate, context-driven results by using NLP, synonym lists, and fine-tuned queries.

Building this required careful planning, a robust ingestion pipeline, and a scoring system that balances relevance and precision. The KB doesn’t just store information; it’s designed to surface answers quickly and intuitively.

Here is a preview of the KB article manager:

A preview of the article Editor:

3. Query Tools in Action

The query tester is an example of CodexMCP’s potential. Here, operators can:

• Write and test advanced OpenSearch queries.
• Limit results to specific fields like titles and scores.
• Dynamically adjust parameters like fuzziness to fine-tune results.

This capability speeds up troubleshooting and provides transparency into how data is queried and retrieved.

Here is a preview of the built-in Query tester:

Authentication and Interface Design

The authentication system in CodexMCP is built on a robust RBAC (Role-Based Access Control) model, ensuring secure and granular access management. Every endpoint is protected with JWT (JSON Web Tokens), which are verified each time they’re accessed. This ensures that only authorized users can interact with the system, providing both security and flexibility.

The interface itself is detached from the core system, meaning the Go engine focuses solely on providing token-protected endpoints. What you do with the data returned from these endpoints is entirely up to you. However, the interface provided by default is already finely tuned to work seamlessly with the system, so your results may vary.

The Codebase

The vision for this project started with a simple but ambitious goal: to build a better knowledge base, leveraging OpenSearch and NLP finely tuned for telecommunications operations. What began as a way to solve the inefficiencies of existing knowledge management tools has now grown into CodexMCP, a fully modular system designed to unify telecom operations into a seamless, interconnected platform.

Below is a glimpse into the heart of CodexMCP—the current codebase. This is not just a collection of static ideas or mockups; it's a living, breathing work in progress.

The modular structure reflects the platform's scalability, efficiency, and purpose-built design, evolving to meet the unique needs of rural telecommunications. Each component is carefully crafted, with Go modules driving the logic and integration.

Each module has a purpose, but it's important to note that the structure of the tree may evolve over time. As the project matures, modules will be refined and reorganized into a more logical flow. We’re still in the early stages of development, so flexibility is key as CodexMCP takes shape.

One of the most complex parts of this project is the knowledge base (KB). With so many moving parts—like categorizing articles, linking related resources, and integrating search functionality—it’s a challenge to ensure everything ties together seamlessly. On the other hand, components like logs and metrics tend to be easier to manage because they are typically immutable time series data, allowing for straightforward processing and analysis.

• The api directory powers the endpoints that interact with the system, from managing knowledge base articles to handling authentication.
• oscodex is where OpenSearch integration comes to life, managing connections, indices, and core database mappings.
• middleware ensures secure and seamless operations, including JWT generation and validation for user authentication.

This tree illustrates the effort and care behind CodexMCP. It's not just a knowledge base; it's a framework for connecting data, processes, and teams into a unified system.

And How Will I Test This Outside of an ISP Environment?

To ensure CodexMCP meets the demands of real-world telecom operations, I’ll be testing it in a fully virtual ISP stack built in Proxmox. This lab will simulate any ISP's core services, leveraging a suite of open-source tools to replicate the operational environment.

The virtual ISP stack will include:

• VyOS routers for core network routing and traffic management.
• FreeRADIUS for authentication and customer access control.
• Kea DHCP and Bind or PowerDNS for IP address management and DNS resolution.
• Asterisk: Simulating SIP operations and call flow, complete with scripted auto-callers to generate realistic call traffic for testing.
• Mail systems, including both inbound and outbound setups, to simulate email services.
• Web servers to replicate hosting environments.
• Simulated IPTV services for video offerings.
• Other end-user services like monitoring tools for logs and metrics.

While my lab can emulate most of an ISP’s stack, there are some systems I can’t replicate fully without access to real-world data. For example:

• FTTH (fiber-to-the-home) systems like Calix.
• DOCSIS for cable modem management.
• SS7 signaling for voice networks.

These require access to live data and specialized hardware, which I don’t have in the lab. That said, the lab environment still provides a powerful testing ground for CodexMCP’s core features, like tying logs to the Knowledge Base, integrating monitoring systems, and simulating real customer workflows.

If someone were to offer access to real-world data for FTTH, DOCSIS, or SS7, it would make the testing process even more robust. However, I have the knowledge, resources, and tools to build and refine CodexMCP entirely on my own. With open-source technologies like FreeRADIUS, Kea, and Bind, I’m ready to create a fully functional virtual ISP stack that showcases the platform’s potential.

Where It’s Going

CodexMCP is still in its early stages, but the vision is clear. Here’s what’s next:

• Full Integration: Seamlessly tying together monitoring, customer management, and inventory into the Knowledge Base.
• Actionable Insights: Using logs and metrics to proactively surface solutions.
• Scalability: Expanding the platform to serve industries beyond telecommunications.

The ultimate goal is to create a fully interconnected system where every piece of data—logs, tickets, articles, and more—is tied together, providing a comprehensive, actionable view of operations

Why It Matters

By centralizing data and making it actionable, CodexMCP isn’t just a platform; it’s a new way of thinking about telco operations.

This is just the beginning. Stay tuned as CodexMCP evolves into my vision for easier ISP operations.

--Gotta Start Somewhere
-Bryan Vest