Forem: Murat Süzen

I’ve officially elevated the .NET AI Architect Laboratory project to a fully autonomous code analysis engine! 🚀

Murat Süzen — Thu, 21 May 2026 13:33:54 +0000

This project positions AI not as an "overhead," but as a true "engineering partner," automating complex analysis processes end-to-end.

Key Capabilities:
✅ Provider Agnosticism: Seamlessly switch between Gemini 2.5 Flash and Groq (Llama 3.3) without altering your system core.
✅ Null Mode (Uninterrupted Operation): Ensures your system remains stable and development never stops, even if an AI provider experiences downtime.
✅ Autonomous Agency: Provide your project’s root directory; the agent scans your code, audits architectural boundaries, identifies errors, and generates an enterprise-grade report.
✅ Local Performance: Uses a high-performance, SQLite-based "Corporate Memory" (RAG) layer instead of complex, expensive cloud-based vector databases.

Technical Stack:
🔹 Backend: .NET 10 & Microsoft.Extensions.AI
🔹 Frontend: Angular 19 & Tailwind CSS (Cyber-Dashboard)
🔹 Orchestration: Semantic Kernel
🔹 Architecture: Dual-Engine Topology (Gemini & Groq Integration)

If you are interested in "clean code," autonomous efficiency, and AI-driven architectural analysis, you can explore the source code on GitHub:

👉 https://github.com/muratsuzen/dotnet-ai-lab

DotNet #AI #SoftwareArchitecture #AutonomousAgents #Angular #SemanticKernel #Engineering #DotNet10

.NET 10 and Angular Signals Powered ‘Local-First’ Enterprise RAG (Vector Memory) Architecture

Murat Süzen — Wed, 20 May 2026 14:20:38 +0000

During Phase 3 of my .NET AI Architect Laboratory project development, I completely disabled external and costly cloud-based vector database dependencies (Vendor Lock-in). Instead, I established a Local-First Enterprise RAG infrastructure operating on .NET 10 core, a local SQLite layer, and Angular Signals.

The operations I have performed are as follows:

Cleaning Up Experimental Preview Package Dependencies
I completely eliminated the experimental SemanticKernel.Connectors and VectorData.Abstractions preview packages from the project, which constantly caused version mismatches, unstable structures, and contained vulnerability warnings such as NU1904. I anchored the architecture to the framework’s own native, stable, and long-term supported enterprise packages.
Provider-Agnostic Embedding Substrate
I wrote a pure C# wrapper called GoogleEmbeddingGenerator, abstracting Microsoft’s new enterprise AI standards (Microsoft.Extensions.AI) alongside Google’s official GenAI SDK.

I dynamically cast the high-dimensional double[] arrays produced by the Gemini text-embedding-004 model down to the float[] vectors expected by .NET interfaces.
Architectural Gain: I provided the full flexibility to transition to OpenAI or a completely local LLM model (Ollama/Llama, etc.) in the upcoming stages by simply changing the IoC (DI) registry inside Program.cs, without touching a single line of the core endpoint architecture.

Zero-Dependency Pure C# Cosine Similarity Engine To calculate the semantic proximity between vectors, I created zero dependencies on any heavy external mathematical libraries or third-party Python services. I coded a memory-friendly and high-performance cosine similarity matrix running directly on .NET core:

public static float CosineSimilarity(float[] vectorA, float[] vectorB)
{
if (vectorA.Length != vectorB.Length)
throw new ArgumentException("Vectors must have the same identical dimensions.");

float dotProduct = 0.0f, normA = 0.0f, normB = 0.0f;
for (int i = 0; i < vectorA.Length; i++)
{
dotProduct += vectorA[i] * vectorB[i];
normA += vectorA[i] * vectorA[i];
normB += vectorB[i] * vectorB[i];
}
return (normA == 0.0f || normB == 0.0f) ? 0.0f : dotProduct / ((float)Math.Sqrt(normA) * (float)Math.Sqrt(normB));
}

Deterministic Deduplication Against Data Inflation
To prevent the SQLite table from inflating in case identical code blocks or files are added back-to-back into the system, I established a deterministic Base64 path-hashing mechanism inside the Angular frontend layer (memory-dashboard.component.ts) based on the file path. By ensuring a strictly unique and definite Id is generated for each file content, I triggered the SQLite native ON CONFLICT(Id) DO UPDATE constraint and completely zeroed out the duplicate row inflation within the database.
Knowledge-Augmented Agency Flow
I integrated this created local vector memory with our autonomous multi-tool agent (/api/architect/inspect-autonomous). When the agent receives an architectural analysis task, it fires a query to this local SQLite vector layer in the background before directly scanning physical files on the disk. For example, when a user gives a general objective like “review frontend access ports,” our semantic search engine fetches the unmentioned CORS configuration code snippet from local memory and injects it into the agent’s real-time system context (Prompt). The agent generates decisions fully armed with localized enterprise domain experience.

🖥️ Dashboard RAG Panel Preview
The live screen artifact of the integrated RAG panel functions as follows:

Makale içeriği

Reactive Management Board: Angular Signals & Tailwind UI I visualized this entire local vector stream using Angular’s reactive Signals architecture and a dark-themed Tailwind CSS v3 interface. Driven by a single reactive state flag, the system seamlessly toggles between the Code Analyzer room and the Knowledge RAG room with zero latency, converting the entire control flow into a single cockpit.

🔗 Explore the Code
The next step following the completion of Phase 3: Developing the Automatic Code Ingestion Pipeline (Phase 4), which will automatically track modified code in the background and update local memory on the fly.

👉 GitHub Repository: github.com/muratsuzen/dotnet-ai-lab

The models themselves are just engines we rent; the true value lies in the architectural substrate, the context, and the documentation we build around them. This lab is my permanent digital logbook of that journey.

.NET AI Architect Laboratory: Making AI Work and Execute Tools (Phase 2)

Murat Süzen — Wed, 20 May 2026 10:54:55 +0000

In Phase 1 of this project, we built a type-safe “Brain” using .NET 10 and Google Vertex AI. In Phase 2, we successfully gave hands and feet to our AI substrate. By connecting Microsoft Semantic Kernel, we created an autonomous agent that can read real local project files, think independently, and detect security vulnerabilities or performance bottlenecks.

Here is a quick summary of what I accomplished and the critical technical lessons I learned during Phase 2.

🛠️ Key Accomplishments

Autonomous Tool Execution: The AI agent now receives a high-level goal (e.g., “Find architectural patterns and security bugs”). It automatically runs native C# plugins like ListProjectFiles and ReadCodeFile to explore and analyze the workspace without manual guidance.

Dynamic Provider Routing: I implemented a dynamic runtime pipeline. The system can switch between Gemini 2.5 Flash and Groq (Llama 3.3 / Llama 3.1) on the fly based on user selection, completely decoupling the business logic from a single AI vendor.

Angular 19 Cyber-Dashboard: Built a modern interface using Angular Signals and Tailwind CSS v3 to visualize the agent’s real-time analysis results, complexity scores, and strategic recommendation logs.

🧠 Important Technical Lessons Learned

The .NET Scope Trap: Trying to resolve request-scoped Semantic Kernel instances directly from the root IServiceProvider container crashes the Kestrel server. I resolved this runtime boundary issue by shifting keyed service lookups to HttpContext.RequestServices to keep the kernel container safely isolated per HTTP request.

Enforcing Deterministic JSON: Small models like Llama 3.1 8B love to output conversational text or messy “thought chains” instead of clean data. Prompt engineering alone is too brittle. I fixed this by forcing strict ChatResponseFormat.Json settings at the API gateway level to mechanically guarantee valid JSON parsing.

The Token Bleeding Filter: Forcing an LLM to output rigid JSON payloads while explaining complex source code in Turkish can confuse the token selection matrix, leaking weird characters (like Russian or Chinese letters). Instead of wasting prompt tokens, I added a simple Whitelist Regex Sanitizer inside the client-side Angular signal flow to clean them up instantly.

🖥️ Dashboard Interface Preview

Here is how the live cyber-panel looks when a Llama-driven autonomous agent evaluates local C# source code:

🚀 What’s Next? (Phase 3: Enterprise Memory)

Now that our type-safe brain can execute tools and display results perfectly, the next challenge is context retention. Fitting massive codebases into a single prompt window is expensive and degrades model accuracy.

Next, we start Phase 3: Enterprise Memory (RAG). I will integrate PostgreSQL/pgvector into the gateway to give our agent a permanent memory substrate of project histories and engineering standards.

🔗 Explore the Code

The complete blueprint, architecture blueprints, and step-by-step implementation files for Phase 2 are fully open-source. Feel free to explore, clone, or follow along as the laboratory evolves:

👉 GitHub Repository: github.com/muratsuzen/dotnet-ai-lab

.NET AI Architect Laboratory: My Architectural Experiments and Learning Journey in the AI Ecosystem (Phase 1)

Murat Süzen — Wed, 20 May 2026 10:52:04 +0000

n an era where artificial intelligence technologies are advancing at breakneck speed, the best way to truly grasp new libraries and paradigms is to roll up your sleeves and get into the kitchen. As a software developer, I launched the .NET AI Architect Laboratory project to pull back the curtain on the underlying mechanics of integrating LLMs into our applications, and to explore the absolute boundaries of building flexible, modular architectures.

For me, this laboratory is far from a commercial endeavor; it is a personal learning journey where I discover new technologies, document my findings, and build a sandbox grounded in enterprise-grade architectural standards.

🎯 Why This Lab?

My primary motivation in this project is to look past standard “quick-start” documentation and truly master the engineering philosophy behind AI integration. The core goals I established for this laboratory include:

Understanding the Kitchen: Going beyond basic API calls to deeply comprehend the architectural costs and mechanics of treating LLMs as plug-and-play engines.

Forging My Own Standards: Handcrafting and testing the cleanest, most sustainable design patterns for AI integration within the .NET ecosystem.

Preparing for Tomorrow’s Tech: Moving past being a passive consumer of ready-made libraries, and reaching a level of competency where I can design end-to-end AI data flows, orchestration, and security from scratch.

🧠 How My Learning Journey is Progressing

This process has been an incredibly rewarding, educational, and discovery-filled experience. A few highlights from this journey so far:

Adapting to an Evolving Ecosystem: Experiencing live version upgrades, shifting method names, and breaking changes in highly nascent libraries like Microsoft.Extensions.AI and the newest official vendor SDKs (such as Google.GenAI) has been a phenomenal learning experience.

Marrying the Rigid and the Fluid: I learned how to build a translation bridge between the strict, type-safe world of .NET and the highly fluid, unpredictable nature of generative AI outputs.

Learning through Failure: Encountering role-matching discrepancies, authentication hurdles, and schema alignment issues during development allowed me to gain a much deeper understanding of how these libraries operate under the hood.

🛠️ What I Accomplished in Phase 1

The first phase of the lab focused entirely on building a clean “Brain” architecture, completely insulated from external vendor lock-in:

Enterprise Setup & Security: I built the foundation using a .NET 10 Minimal API. Instead of passing brittle API keys through code, I established enterprise security standards by leveraging Google Vertex AI via IAM and Service Account (vertex-key.json) mechanics through Application Default Credentials (ADC).

Abstraction via the Adapter Pattern: To prevent the API endpoint from tightly coupling with the native Google SDK, I developed a custom adapter (GoogleGenAIChatClient) that implements Microsoft’s standard IChatClient interface.

Type-Safe JSON Management: To ensure that raw AI outputs could be safely and directly deserialized into C# objects (ArchitectureReview), I enforced strict schema controls. By fine-tuning parameters like Temperature (down to 0.2f) and setting the response MIME type, I successfully locked down the model’s output format.

Dynamic Provider Routing: I designed an elegant Dependency Injection (DI) structure capable of switching between different underlying AI engines at runtime simply by modifying a single line in appsettings.json (e.g., SelectedProvider: "Gemini").

🚀 What’s Next? (Phase 2 and Beyond)

Now that the core infrastructure is completely provider-agnostic, it’s time to test more autonomous workflows within the laboratory:

Giving the AI Hands and Feet (Orchestration): I will integrate Microsoft.SemanticKernel into the project to present native C# functions (Native Plugins) to the model as tools, opening the door to experimenting with autonomous execution loops.

Code Analysis Capability (Function Calling): The first plugin I develop will test the model’s ability to scan real C# source files in the repository and generate autonomous architectural reviews.

UI & Visualization: To visualize the analysis results and track model performance metrics over time, I will build an Architecture Dashboard powered by Angular 19.

Advanced Memory & Agency (RAG & Agents): In later stages, I plan to explore vector database integrations (PostgreSQL/pgvector) and step into multi-agent systems via the Model Context Protocol (MCP).

🔗 Explore the Code

The complete blueprint, architecture blueprints, and step-by-step implementation files for Phase 1 are fully open-source. Feel free to explore, clone, or follow along as the laboratory evolves:

👉 GitHub Repository: github.com/muratsuzen/dotnet-ai-lab