Automating Architecture Documentation from .NET Codebases Using Amazon Bedrock AgentCore

Maintaining accurate, up-to-date architecture documentation across large-scale enterprise applications is a legacy challenge for software engineering organizations. In fast-paced development environments—especially within global interdealer brokers and financial institutions running extensive .NET codebases—code evolves rapidly while architectural diagrams and technical documentation inevitably drift out of sync. Static Confluence pages and manually drawn Visio diagrams become obsolete almost as soon as they are published.

To solve this, advanced engineering teams are shifting from manual documentation to automated, agent-driven pipelines. By combining Amazon Bedrock AgentCore, Amazon Bedrock Knowledge Bases, and AWS CodePipeline, developers can build an agentic architecture documentation system that continuously parses C# codebases, synthesizes sequence and C4 component diagrams, and updates vector-indexed knowledge repositories upon every git commit.

In this technical guide, we break down the architecture of this automated documentation system, analyze code parser implementations, provide diagram generation patterns using Claude 3.5 Sonnet, and discuss how platforms like n1n.ai help enterprise developers optimize multi-LLM orchestration for code parsing and document generation.

The Architecture Documentation Challenge in Enterprise .NET Codebases

Enterprise .NET solutions often comprise dozens of solution (.sln) files, hundreds of class projects (.csproj), dependency injection setups, Entity Framework Core ORM mappings, and cross-service gRPC or REST contracts. For large organizations, reverse-engineering this topology requires significant developer hours.

Traditional documentation approaches fail for three core reasons:

1. High Maintenance Overhead: Engineers spend hours updating Mermaid or PlantUML scripts manually.
2. Lack of Semantic Understanding: Basic static AST (Abstract Syntax Tree) generators output messy, unreadable node graphs without conceptual grouping.
3. Information Silos: Documentation lives separately from code execution and developer search interfaces.

By introducing an LLM agentic framework via Amazon Bedrock AgentCore, the documentation pipeline moves beyond mechanical code parsing. The agent acts as an autonomous software architect: it understands service boundaries, controller endpoints, middleware filters, and database context mappings, rendering clear architectural diagrams and vectorizing technical domain knowledge for downstream query pipelines.

Agentic System Architecture Overview

The continuous documentation pipeline operates on an event-driven architecture triggered by repository changes. Below is the workflow breakdown:

[Developer Commit] -> [AWS CodePipeline] 
                         |
                         v
             [Roslyn AST & Metadata Extractor]
                         |
                         v
             [Amazon Bedrock AgentCore Agent]
               /                        \\
              v                          v
  [Diagram Engine (Mermaid/PlantUML)]  [Amazon Bedrock Knowledge Base]
              |                          |
              v                          v
   [S3 / Developer Portal]       [Vector DB (OpenSearch Serverless)]

Core System Components

1. Source Trigger & Build Pipeline (AWS CodePipeline / GitHub Actions): Listens for merged pull requests in C# repositories and triggers the documentation agent workflow.
2. Metadata & AST Parser: Uses Roslyn (.NET Compiler Platform) or lightweight regex/AST extractors to isolate API controllers, interfaces, DTOs, and dependency injection service lifetimes (AddTransient, AddScoped, AddSingleton).
3. Amazon Bedrock AgentCore (Orchestration Engine): Executes multi-step agent reasoning. It prompts foundation models like Anthropic Claude 3.5 Sonnet to translate structural metadata into structured C4 model abstractions.
4. Diagram Synthesis Engine: Converts JSON abstractions generated by the agent into standard Mermaid.js or PlantUML dynamic markup.
5. Knowledge Base Storage: Ingests raw code context and synthesized doc markdown into Amazon Bedrock Knowledge Bases backed by OpenSearch Serverless for instant developer QA.

Technical Implementation: Code Parsing & Diagram Generation

To build this pipeline, the Bedrock Agent requires structured inputs extracted from the target repository. Below is a complete implementation showing how code structural metadata is processed into a dynamic C4 Component diagram using Python and foundation model APIs.

Step 1: Extracting Structural Metadata from .NET

Before calling the LLM agent, a pre-processing script parses C# files to extract controller routes, injected dependencies, and database contexts:

import os
import re
import json

def extract_dotnet_metadata(file_path):
    with open(file_path, "r