# Build Your Own MCP-Powered Document Processing Backend with TX Text Control > This article explains how to create a document processing backend based on MCP using TX Text Control. It reveals structured tools that AI agents can identify and use. It showcases a clean architecture and practical capabilities for session-based document workflows, facilitating the automation of processes that go beyond traditional APIs. - **Author:** Bjoern Meyer - **Published:** 2026-04-16 - **Modified:** 2026-04-16 - **Description:** This article explains how to create a document processing backend based on MCP using TX Text Control. It reveals structured tools that AI agents can identify and use. It showcases a clean architecture and practical capabilities for session-based document workflows, facilitating the automation of processes that go beyond traditional APIs. - **18 min read** (3433 words) - **Tags:** - ASP.NET - ASP.NET Core - MCP - Document Processing - **Web URL:** https://www.textcontrol.com/blog/2026/04/16/build-your-own-mcp-powered-document-processing-backend-with-tx-text-control/ - **LLMs URL:** https://www.textcontrol.com/blog/2026/04/16/build-your-own-mcp-powered-document-processing-backend-with-tx-text-control/llms.txt - **LLMs-Full URL:** https://www.textcontrol.com/blog/2026/04/16/build-your-own-mcp-powered-document-processing-backend-with-tx-text-control/llms-full.txt - **GitHub Repository:** https://github.com/TextControl/TXTextControl.MCPDocumentServer --- The Model Context Protocol (MCP) is an open standard that gives AI agents structured access to data and functionality. Instead of exposing traditional application programming interfaces (APIs), the MCP defines a consistent way of describing and invoking capabilities as tools. This makes services directly accessible and understandable for agent-based systems. In this example, MCP is used as the protocol layer to provide controlled access to documents. Integrating ServerTextControl exposes document operations, such as loading, inspecting, modifying and exporting content, as structured MCP tools. This allows agents to reliably and consistently work with existing documents or create new ones. This article provides an overview of the architecture, concepts, and capabilities of the sample, and explains why the sample is important for the future of document automation. ##### What is the Model Context Protocol (MCP)? The Model Context Protocol (MCP) is an open standard that defines how AI systems interact with external tools and services. Rather than relying on loosely structured prompts or custom API integrations, the MCP establishes a formal agreement between AI models and backend systems. Through this contract, an AI assistant can: - Discover available tools dynamically - Understand the capabilities and requirements of each tool - Invoke tools with structured inputs and receive structured outputs - Chain multiple tools into workflows In simple terms, MCP transforms the backend into a toolbox for AI agents. For document processing, this represents a fundamental shift. Rather than writing code to call APIs, AI systems can invoke operations directly. - Load a document from a URL - Extract text or metadata - Modify content based on instructions - Export to different formats The TX Text Control MCP Document Server demonstrates how to present these capabilities in a clean and structured manner. By adhering to the MCP standard, the server ensures that any AI agent that understands MCP can interact with documents without requiring custom integration. ###### Why MCP Changes Document Processing Traditional document processing APIs require developers to write code that interacts with specific endpoints, handles authentication, and manages data formats. This can create a barrier for AI agents, which may have difficulty understanding or using these APIs without human assistance. MCP servers, however, are designed for AI agents, which changes the game. - From endpoints → to tools - From manual orchestration → to autonomous workflows - From code → to intent The result is a system in which AI can actively work with documents instead of just generating code to process them. However, this requires implementation based on the TX Text Control API. In other words, the MCP endpoint is an additional abstraction layer on top of the API. ##### What the MCP Document Server Sample Provides At its core, the sample is an MCP server based on sessions and built with .NET. It offers tools for working with documents on a server-side instance managed by TX Text Control. Each session corresponds to a single document, enabling agents to maintain state across interactions. Rather than covering every feature, this sample focuses on demonstrating how to structure an MCP server for document processing and providing a foundation for building more complex capabilities. The sample also illustrates how to preserve document state across tool calls and how to present functionalities in a manner that is discoverable and usable by AI agents. ###### Application Architecture The sample adheres to a clean, extensible architecture that distinguishes MCP concerns from document processing logic. ![Workflow Diagram](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/workflow.webp "Workflow Diagram") 1. **MCP Integration Layer:** The server is built on top of the [ModelContextProtocol.AspNetCore](https://www.nuget.org/packages/ModelContextProtocol.AspNetCore/) package. This provides: - MCP endpoint handling (POST /mcp) - Tool discovery and registration - Request/response handling for AI clients The MCP layer is responsible for translating between MCP requests and the underlying document operations. 2. **Tool Layer (McpServerToolType)** Tools are implemented as classes registered using the MCP framework (via McpServerToolType). These classes define: - The tool name - Input parameters - Execution logic This separation keeps responsibilities clear and makes it easy to extend the server with additional capabilities. 3. **Abstraction Layer (ITxDocumentEngine)** The ITxDocumentEngine interface abstracts the document processing logic. It defines methods for loading, inspecting, modifying and exporting documents. The implementation of this interface uses the TX Text Control API to perform actual operations on the document instance. 4. **Implementation Layer (ServerTextControlDocumentEngine)** This class implements the ITxDocumentEngine interface using the ServerTextControl class. It manages a document instance for each session and provides methods to manipulate it based on the defined interface: - Loading documents from Base64 - Performing searches and formatting - Exporting documents to different formats This layer is where the core document processing logic resides, and it can be extended to support additional features as needed. ###### Session-Based Document Handling One of this sample's key features is its session-based approach to handling documents. Each session corresponds to a single document, enabling AI agents to retain information across multiple interactions. This means that an agent can load a document, perform several operations on it and then export it, all within the same session. The server manages these sessions and ensures that the correct document instance is used for each tool invocation. This enables multi-step workflows where an AI agent can iteratively work with a document, making changes based on previous results. For example, an agent could: - Load a document from a URL - Extract text and identify key sections - Modify content based on instructions (e.g., *"Format the third paragraph with bold text"*) - Export the modified document to PDF ###### Key Capabilities Demonstrated The sample provides a range of tools that demonstrate the core capabilities of the MCP server. The following table summarizes the available tools, their descriptions and return values: | Tool | Description | Return Value | |---|---|---| | **DocumentTools** | | `create_document()` | Creates a new document session and initializes an empty document in TX internal format. | Returns a generated `sessionId` to be used in subsequent tool calls. | | `load_from_base64(request, sessionId?)` | Loads a Base64-encoded document into a session. If `sessionId` is provided, the existing session document is overwritten. If omitted, a new session is created automatically. | Returns the target `sessionId` to continue with content tools. | | `get_as_base64(request)` | Exports the current session document as Base64. Supported formats are `tx`, `docx`, `pdf`, `html`, and `md`. | Returns `sessionId`, normalized `format`, and `base64Document`. | | `get_session(sessionId)` | Validates that a session exists and can be used before content operations. | Returns the existing `sessionId` or a `not_found` error if it does not exist. | | `delete_session(sessionId)` | Deletes a session and removes all related session files from disk. | Returns `{ deleted, sessionId }`, where `deleted` indicates success. | | **ContentTools** | | `format_text(sessionId, request)` | Applies character formatting to either an explicit text range or a paragraph by index. Supported properties include `bold`, `italic`, `underline`, `color_hex`, `font_name`, and `font_size`. | Returns the `sessionId` after saving changes. | | `get_paragraphs(sessionId, start?, end?)` | Reads paragraph text values from a session document, optionally sliced by paragraph index. | Returns `sessionId` and a `paragraphs` array. | | `search_text(sessionId, text?, matchCase?, wholeWord?)` | Performs paragraph-level text search and returns matching paragraph indices. | Returns an array of paragraph indices where matches occur. | | `search_text_ranges(sessionId, text?, matchCase?, wholeWord?)` | Performs character-level search and returns exact match ranges. | Returns `sessionId` and a `matches` array with `start` and `length`. | | `get_text(sessionId)` | Retrieves the complete plain-text content of the session document. | Returns the full plain-text document content. | ###### Exploring the MCP Server with Postman To demonstrate the workflow, we will examine the MCP tools when connected to Postman. Although Postman does not offer autonomous planning, tool selection or multi-step reasoning capabilities like an AI agent would, it is still an excellent way to explore how the MCP server behaves in practice. With Postman, you can inspect raw MCP requests and responses, see how tools are exposed, understand expected parameters and examine returned payloads in a controlled environment. This makes Postman a practical choice for learning the structure of the available tools, testing individual operations and understanding how a client interacts with the MCP endpoint, before connecting the server to an AI agent. ###### Loading a Document To load a document, you can use the load\_from\_base64 tool. In Postman, you would send a POST request to the MCP endpoint with a JSON body that specifies the tool name and parameters: ![Step 1: Loading a document](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/step1.webp "Step 1: Loading a document") For demo purposes, we are loading a simple Markdown document that contains various formatting elements. The server will create a new session, load the document into a ServerTextControl instance and return the generated sessionId. This session ID is crucial for all subsequent operations, as it allows the server to maintain state across tool calls. ``` ### NON-DISCLOSURE AGREEMENT (NDA) This Non-Disclosure Agreement ("Agreement") is entered into as of **{{EffectiveDate}}** between: **Disclosing Party:** {{DisclosingPartyName}} {{DisclosingPartyAddress}} and **Receiving Party:** {{ReceivingPartyName}} {{ReceivingPartyAddress}} --- #### 1. Purpose The Parties wish to explore a business relationship in connection with **{{Purpose}}** (the "Purpose"). In the course of this relationship, confidential information may be disclosed. --- #### 2. Definition of Confidential Information "Confidential Information" means any non-public, proprietary, or sensitive information disclosed by the Disclosing Party, including but not limited to: - Business plans, strategies, and financial information - Technical data, software, and documentation - Customer and supplier information - Trade secrets and know-how Confidential Information may be disclosed in written, electronic, or oral form. ``` Internally, the document is kept in the TX Text Control internal format, which preserves all formatting and structure. The server manages this document instance for the session, allowing subsequent tools to operate on it without needing to reload or reprocess the content. You can see that the server returns a structured response that includes the sessionId, which is essential for maintaining context in future interactions. We will now use this session ID to perform operations on the loaded document, such as searching for text, applying formatting and exporting the modified document. In the next screenshot, we will use the get\_paragraphs tool to retrieve the text of the first five paragraphs in the document, which demonstrates how we can interact with the session document and extract information from it. ![Step 2: Retrieving paragraphs](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/step2.webp "Step 2: Retrieving paragraphs") The returned JSON response includes the sessionId and an array of paragraphs, which shows that the server is correctly maintaining the document state and allowing us to interact with it through the defined tools. ``` { "content": [ { "type": "text", "text": { "sessionId": "c6091b27376a4a53bad656ba90d27f62", "paragraphs": [ "NON-DISCLOSURE AGREEMENT (NDA)\r\n", "This Non-Disclosure Agreement (\"Agreement\") is entered into as of {{EffectiveDate}} between:\r\n", "Disclosing Party: {{DisclosingPartyName}} {{DisclosingPartyAddress}}\r\n", "and\r\n", "Receiving Party: {{ReceivingPartyName}} {{ReceivingPartyAddress}}\r\n" ] } } ] } ``` In the next step, we want to apply formatting to a specific text range. We can use the format\_text tool to make the second paragraph bold and pink. This demonstrates how we can modify the document content based on instructions, which is a key capability for AI-driven document processing. ![Step 3: Formatting text](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/step3.webp "Step 3: Formatting text") After sending the request, the server processes the formatting operation and returns the sessionId to indicate that the changes have been saved. We can then use the get\_as\_base64 tool to export the modified document as a Base64-encoded string, which can be decoded to retrieve the final document in the desired format (e.g., PDF, DOCX). ![Step 4: Exporting the document](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/step4.webp "Step 4: Exporting the document") We requested the document in PDF format, and the server returns the Base64-encoded PDF content along with the session ID and format. This demonstrates the full workflow of loading a document, modifying it and exporting the result, all through structured MCP tool calls. ![Step 5: PDF Output](https://s1-www.textcontrol.com/assets/dist/blog/2026/04/16/a/assets/pdf.webp "Step 5: PDF Output") In summary, we uploaded a document, extracted its paragraphs, applied formatting to a specific range, and exported the modified document as a PDF. This illustrates how the MCP server enables AI agents to interact with documents dynamically and flexibly, eliminating the need to write code or manage API calls directly. The server's tools enable a wide range of operations, and its session-based architecture maintains state across interactions, allowing complex workflows to evolve over time. ##### Using the MCP Server with AI Agents Postman is a great tool for exploring the MCP server. However, the real power of this architecture is unlocked by connecting it to AI agents that can autonomously discover and invoke tools based on their understanding of the task at hand. Agents like Copilot can interact with the MCP server and perform document processing tasks without human intervention. When connected to an AI agent, the MCP server allows prompts to be structured in a way that the agent can understand the available tools and their capabilities. For example, an agent could receive a prompt like: ``` Load this document and return all paragraphs that contain the word "liability". Then, make those paragraphs bold and export the modified document as PDF. ``` The agent would then parse this prompt, identify the required tools (load\_from\_base64, get\_paragraphs, format\_text, get\_as\_base64) and invoke them in the correct sequence to achieve the desired outcome. This level of autonomy is what makes MCP servers so powerful for document processing, as it allows AI agents to work with documents in a natural and flexible way, without needing explicit programming or API management. ``` Load the document, search for the word "urgent", and change the text color to red for all matches. ``` In this example, the agent would use the search\_text\_ranges tool to find all occurrences of "urgent" and then apply the format\_text tool to change the text color to red for those specific ranges. This demonstrates how agents can perform complex document modifications based on simple natural language instructions, leveraging the structured capabilities provided by the MCP server. ##### From REST APIs to AI Tools One of the most significant shifts when working with MCP is moving from thinking in terms of REST APIs to thinking in terms of AI tools. In a traditional API, you might have endpoints like `POST /documents` or `GET /documents/{id}`. With MCP, these operations are exposed as tools that an AI agent can discover and invoke based on its understanding of the task at hand. Instead of building endpoints like: ``` POST /load POST /search POST /export ``` You define tools like: ``` load_from_base64(request, sessionId?) search_text(sessionId, text?, matchCase?, wholeWord?) get_as_base64(request) ``` This enables AI agents to interact with document processing backends in a more natural and flexible manner. Agents can choose which tools to use based on the task at hand, chain multiple tools together, and work with documents iteratively, eliminating the need for human intervention to write code or manage API calls. ##### Running the Sample To run the sample, follow these steps: 1. Ensure you have the required environment set up, including .NET 8.0 SDK and TX Text Control .NET Server for ASP.NET 34.0. 2. Clone the GitHub repository 3. Open the solution in Visual Studio 2026 4. Build the solution to restore dependencies 5. Run the project to start the MCP server Once the server is up and running, you can interact with it using any AI agent that is compatible with MCP, such as Copilot. The server will make the defined tools available to the agent, enabling it to load documents, perform operations and export results as required. This sample provides the basis for developing more sophisticated document processing capabilities. You can expand the range of operations available to include advanced formatting, content analysis and integration with external data sources, for example. The flexible and scalable architecture allows you to evolve your MCP server as your needs grow. ##### Conclusion The TX Text Control MCP Document Server sample shows how to create a document processing backend that can be accessed directly by AI agents via the Model Context Protocol (MCP). By structuring document operations as tools and managing state through sessions, it provides a powerful foundation for enabling AI-driven document workflows. This approach marks a significant shift in our thinking about document automation, shifting the focus from traditional APIs to a more dynamic, agent-friendly model. As AI continues to evolve, MCP servers like this one will play a crucial role in unlocking new intelligent and autonomous ways of working with documents. ##### Frequently Asked Questions What is the Model Context Protocol (MCP)? ------------------------------------------ The Model Context Protocol (MCP) is an open standard that enables AI agents to interact with external systems through structured tools instead of traditional APIs. It allows agents to discover available capabilities, understand required inputs, and execute operations with predictable, structured outputs. How does MCP differ from traditional REST APIs? ------------------------------------------------ Traditional REST APIs require developers to write code for specific endpoints and orchestrate workflows manually. MCP replaces endpoints with self-describing tools that AI agents can discover and invoke dynamically, enabling intent-driven execution rather than hardcoded integrations. Why is MCP important for document processing? ---------------------------------------------- MCP allows AI agents to directly interact with documents by invoking tools such as loading, searching, modifying, and exporting content. This eliminates the need for custom API integrations and enables automated, multi-step document workflows. What does the MCP Document Server sample demonstrate? ------------------------------------------------------ The sample demonstrates how to build an MCP server for document processing using TX Text Control. It shows how to structure tools, manage document state using sessions, and expose document operations in a way that AI agents can easily consume. How does session-based document handling work? ----------------------------------------------- Each session represents a single document instance on the server. The session persists across multiple tool calls, allowing AI agents to perform multi-step workflows such as loading, modifying, and exporting documents without reprocessing or reloading them. What is the role of ServerTextControl in this architecture? ------------------------------------------------------------ The ServerTextControl class is used as the document processing engine. It handles loading documents, modifying content, applying formatting, and exporting to formats such as PDF or DOCX within each session. What are MCP tools? -------------------- MCP tools are structured operations exposed by the server. Each tool defines its name, input parameters, and execution logic. Examples include creating documents, searching text, formatting content, and exporting files. What document operations are supported by the sample? ------------------------------------------------------ The sample includes tools for creating documents, loading content from Base64, retrieving paragraphs, searching text, applying formatting, and exporting documents to formats such as PDF, DOCX, HTML, Markdown, and TX internal format. How can I test the MCP server without an AI agent? --------------------------------------------------- You can use tools like Postman to send requests directly to the MCP endpoint (POST /mcp). This allows you to inspect tool definitions, test operations, and analyze request and response payloads in a controlled environment. Can AI agents automate document workflows using MCP? ----------------------------------------------------- Yes. AI agents can interpret natural language instructions, discover the required tools, and execute them in sequence. For example, an agent can load a document, search for specific content, apply formatting, and export the result automatically. What are typical workflows enabled by MCP? ------------------------------------------- Typical workflows include loading a document, extracting text or paragraphs, searching for keywords, applying formatting, and exporting the modified document. These workflows can be executed step-by-step by an AI agent within a single session. What technologies are required to run the sample? -------------------------------------------------- To run the sample, you need the .NET 8.0 SDK, TX Text Control .NET Server (version 34.0), and Visual Studio. After building and running the project, the MCP server is available for interaction. How extensible is the MCP server architecture? ----------------------------------------------- The architecture is modular and extensible. New tools can be added easily, and the abstraction layer allows you to extend document processing functionality without changing the MCP integration layer. How do AI agents discover available tools? ------------------------------------------- MCP includes a tool discovery mechanism that allows AI agents to query the server for available tools, including their parameters and expected outputs. This enables agents to dynamically adapt to new capabilities. What is the advantage of using tools instead of endpoints? ----------------------------------------------------------- Tools are self-describing and structured, making them easier for AI agents to understand and use. This enables flexible, dynamic workflows without requiring predefined API integrations or manual orchestration. Can the MCP server be used in production environments? ------------------------------------------------------- Yes. The sample provides a solid foundation for building production-ready systems. It can be extended with additional tools, security features, and integrations to support advanced AI-driven document processing scenarios. --- ## About Bjoern Meyer As CEO, Bjoern is the visionary behind our strategic direction and business development, bridging the gap between our customers and engineering teams. His deep passion for coding and web technologies drives the creation of innovative products. If you're at a tech conference, be sure to stop by our booth - you'll most likely meet Bjoern in person. With an advanced graduate degree (Dipl. Inf.) in Computer Science, specializing in AI, from the University of Bremen, Bjoern brings significant expertise to his role. In his spare time, Bjoern enjoys running, paragliding, mountain biking, and playing the piano. - [LinkedIn](https://www.linkedin.com/in/bjoernmeyer/) - [X](https://x.com/txbjoern) - [GitHub](https://github.com/bjoerntx) --- ## Related Posts - [From Legacy Microsoft Office Automation to a Future-Ready Document Pipeline with C# .NET](https://www.textcontrol.com/blog/2026/03/02/from-legacy-microsoft-office-automation-to-a-future-ready-document-pipeline-with-csharp-dot-net/llms.txt) - [TX Text Control for Linux Preview: Document Processing in ASP.NET Core on Azure App Services](https://www.textcontrol.com/blog/2024/12/17/tx-text-control-for-linux-preview-document-processing-in-asp-net-core-on-azure-app-services/llms.txt) - [Hello Linux! Almost There - A Game-Changer for Document Processing](https://www.textcontrol.com/blog/2024/12/12/hello-linux-almost-there-a-game-changer-for-document-processing/llms.txt) - [TXTextControl.Markdown.Core 34.1.0-beta: Work with Full Documents, Selection, and SubTextParts](https://www.textcontrol.com/blog/2026/04/14/txtextcontrol-markdown-core-34-1-0-beta-work-with-full-documents-selection-and-subtextparts/llms.txt) - [5 Layout Patterns for Integrating the TX Text Control Document Editor in ASP.NET Core C#](https://www.textcontrol.com/blog/2026/04/09/5-layout-patterns-for-integrating-the-tx-text-control-document-editor-in-aspnet-core-csharp/llms.txt) - [Extracting Structured Table Data from DOCX Word Documents in C# .NET with Domain-Aware Table Detection](https://www.textcontrol.com/blog/2026/04/03/extracting-structured-table-data-from-docx-word-documents-in-csharp-dotnet-with-domain-aware-table-detection/llms.txt) - [Introducing Text Control Agent Skills](https://www.textcontrol.com/blog/2026/03/27/introducing-text-control-agent-skills/llms.txt) - [Deploying the TX Text Control Document Editor from the Private NuGet Feed to Azure App Services (Linux and Windows)](https://www.textcontrol.com/blog/2026/03/25/deploying-the-tx-text-control-document-editor-from-the-private-nuget-feed-to-azure-app-services-linux-and-windows/llms.txt) - [Why Structured E-Invoices Still Need Tamper Protection using C# and .NET](https://www.textcontrol.com/blog/2026/03/24/why-structured-e-invoices-still-need-tamper-protection-using-csharp-and-dotnet/llms.txt) - [AI Generated PDFs, PDF/UA, and Compliance Risk: Why Accessible Document Generation Must Be Built Into the Pipeline in C# .NET](https://www.textcontrol.com/blog/2026/03/23/ai-generated-pdfs-pdf-ua-and-compliance-risk-why-accessible-document-generation-must-be-built-into-the-pipeline-in-c-sharp-dot-net/llms.txt) - [File Based Document Repository with Version Control in .NET with TX Text Control](https://www.textcontrol.com/blog/2026/03/20/file-based-document-repository-with-version-control-in-dotnet/llms.txt) - [Create Fillable PDFs from HTML Forms in C# ASP.NET Core Using a WYSIWYG Template](https://www.textcontrol.com/blog/2026/03/17/create-fillable-pdfs-from-html-forms-in-csharp-aspnet-core-using-a-wysiwyg-template/llms.txt) - [Why HTML to PDF Conversion is Often the Wrong Choice for Business Documents in C# .NET](https://www.textcontrol.com/blog/2026/03/13/why-html-to-pdf-conversion-is-often-the-wrong-choice-for-business-documents-in-csharp-dot-net/llms.txt) - [Inspect and Process Track Changes in DOCX Documents with TX Text Control with .NET C#](https://www.textcontrol.com/blog/2026/03/10/inspect-and-process-track-changes-in-docx-documents-with-tx-text-control-with-dotnet-csharp/llms.txt) - [Text Control at BASTA! Spring 2026 in Frankfurt](https://www.textcontrol.com/blog/2026/03/06/text-control-at-basta-spring-2026-in-frankfurt/llms.txt) - [We are Gold Partner at Techorama Belgium 2026](https://www.textcontrol.com/blog/2026/02/26/we-are-gold-partner-techorama-belgium-2026/llms.txt) - [Text Control Sponsors & Exhibits at BASTA! Spring 2026 in Frankfurt](https://www.textcontrol.com/blog/2026/02/26/text-control-sponsors-exhibits-basta-spring-2026-frankfurt/llms.txt) - [Azure DevOps with TX Text Control .NET Server 34.0: Private NuGet Feed and Azure Artifacts](https://www.textcontrol.com/blog/2026/02/25/azure-devops-with-tx-text-control-dotnet-server-34-0-private-nuget-feed-and-azure-artifacts/llms.txt) - [TX Text Control 34.0 SP2 is Now Available: What's New in the Latest Version](https://www.textcontrol.com/blog/2026/02/18/tx-text-control-34-0-sp2-is-now-available/llms.txt) - [Build a Custom Backstage View in ASP.NET Core with TX Text Control](https://www.textcontrol.com/blog/2026/02/17/build-a-custom-backstage-view-in-aspnet-core-with-tx-text-control/llms.txt) - [Configuring Web.Server.Core for TX Text Control Document Editor: Changing Ports and IP Versions](https://www.textcontrol.com/blog/2026/02/12/configuring-web-server-core-for-tx-text-control-document-editor-changing-ports-and-ip-versions/llms.txt) - [Software Origin, Compliance, and Trust: Made in Germany](https://www.textcontrol.com/blog/2026/02/11/software-origin-compliance-and-trust-made-in-germany/llms.txt) - [Building a TX Text Control Project with GitHub Actions and the Text Control NuGet Feed](https://www.textcontrol.com/blog/2026/02/09/building-a-tx-text-control-project-with-github-actions-and-the-text-control-nuget-feed/llms.txt) - [ASP.NET Core Document Editor with Backend via the Text Control Private NuGet Feed](https://www.textcontrol.com/blog/2026/02/09/aspnet-core-document-editor-private-nuget-feed/llms.txt) - [Text Control Private NuGet Feed](https://www.textcontrol.com/blog/2026/02/09/text-control-private-nuget-feed/llms.txt)