All Articles

BlueRobin's Archives looks like a RAG app from the outside. Inside, it's a collection of specialist agents — triage, finance, health, tax, entity resolution, insight, and retrieval — each with its own job, coordinating over an event bus.

How BlueRobin combines multi-model vector search, Reciprocal Rank Fusion, knowledge graph traversal, and full-document context assembly to answer complex questions across your entire archive.

A walkthrough of how BlueRobin transforms any uploaded document — PDF, image, or Office file — into a fully analysed, encrypted, and semantically indexed record.

How BlueRobin extracts named entities from every document, resolves them into a canonical taxonomy, and stores a property graph that connects people, organisations, dates, and events across your entire archive.

A streamlined guide to setting up the full stack locally, from secret management with Infisical to running microservices with shared infrastructure.

Revolutionizing cluster operations by replacing kubectl with natural language interaction using the Kubernetes MCP Server.

How we use Model Context Protocol to create a closed-loop design system where agents verify implementation against Figma specs automatically.

Bridging the gap between design and development by using the Model Context Protocol (MCP) to automate UI generation from Figma to Blazor.

Implementing model policy management and token accounting so LLM features remain cost-aware and governable at platform scale.

An end-to-end deployment walkthrough for introducing a new AI service with environment overlays, secret wiring, and production-safe defaults.

A pragmatic analysis of the costs, performance, and complexity of running local LLMs versus cloud providers, and why we adopted a hybrid architecture.

Visual architecture overview of our Telegram integration, showing the complete flow from mobile app to backend services, authentication, and notification pipelines.

Complete guide to deploying our Telegram Bot on Kubernetes, covering Docker builds, Kustomize overlays, secrets management with Infisical, and GitOps with Flux CD.

Building a real-time notification pipeline from document processing events to Telegram messages using NATS Core, environment-prefixed subjects, and the publisher-subscriber pattern.

A deep dive into creating a Telegram Mini App that enables passkey authentication, leveraging Blazor Server, WebAuthn, and Telegram's native theming system.

Going beyond simple webhooks. How to build a robust C# BackgroundService that listens to NATS events and manages a bidirectional Telegram Bot.

Building the ultimate developer portal for the home lab. We integrate 'gethomepage', Spotify Backstage, and secure it all with Authelia SSO.

Running a complex microservices stack on limited hardware. How we use .NET 10 Chiseled Ubuntu images and Native AOT to slash memory usage.

Using NBomber and k6 to find the breaking points of our .NET API. Analysis of CPU vs Memory vs I/O bottlenecks.

How we slashed system latency by 95% by moving from sequential HTTP calls to parallel NATS requests, implementing Redis caching, and tuning Qdrant vector search.

What happens when agent graph node names collide with state keys, and how to design LangGraph flows that remain safe under change.

How to introduce an agent-based retrieval routing layer with health-aware fallback to keep retrieval reliable in production.

A production blueprint for combining graph traversal and vector search to improve recall and precision in document retrieval.

How to evolve entity extraction by combining deterministic and LLM-based providers with confidence-aware ensembling.

How to combine multiple retrieval strategies with reciprocal rank fusion to produce stable, high-quality contexts for LLM responses.

Build intelligent AI agents using Microsoft Semantic Kernel with tool calling, memory, and multi-agent coordination in .NET.

How to extract entities (NER) from documents using LLMs and model them effectively in FalkorDB for knowledge graphs.

Model and query entity relationships using FalkorDB (Redis Graph) for knowledge graphs and connected data in .NET applications.

Extract named entities from documents using spaCy NLP service for building knowledge graphs and improving search relevance.

Techniques for rewriting user queries (HyDE, Expansion) and reranking results to boost retrieval accuracy in Retrieval-Augmented Generation.

Implement a complete Retrieval-Augmented Generation pipeline that combines semantic search with local LLM inference for intelligent document Q&A.

Build a powerful hybrid search system that combines vector embeddings with traditional keyword search for comprehensive document retrieval.

Deploy and configure Qdrant for production semantic search with collection management, filtering, and high availability on Kubernetes.

Create a production-ready embedding pipeline in .NET that generates vector embeddings with Ollama and stores them in Qdrant for semantic search.

Implement effective text chunking strategies for RAG pipelines with semantic boundaries, overlap, and metadata preservation.

Learn how to integrate Docling, an AI-powered document understanding library, into your .NET application for high-quality OCR with layout preservation.

A practical cluster setup guide for running AI services alongside traditional backends with reliable data, messaging, and observability.

Moving from local in-memory limits to cluster-aware NATS KV partitions for fair, durable API throttling in distributed deployments.

A practical strategy for evolving NATS subjects and event naming while keeping producers and consumers compatible during transition windows.

How compare-and-swap semantics in NATS KV can prevent duplicate event processing across multiple worker instances.

Deploy and integrate MinIO for S3-compatible object storage with per-user buckets, encryption, and lifecycle policies.

Deploy a production-ready MinIO cluster on Kubernetes with per-user encryption, bucket policies, and integration with your .NET applications.

Implement distributed tracing, metrics, and logging with OpenTelemetry in .NET applications for full observability.

Implement real-time UI updates in Blazor Server using NATS JetStream instead of SignalR, with progress indicators and state management.

Set up comprehensive monitoring for NATS JetStream with Prometheus, Grafana dashboards, and alerting for production-ready messaging infrastructure.

Discover the hidden powers of NATS. Replace Redis and S3 for internal use cases using the built-in Key-Value Store and Object Store capabilities of JetStream.

Deep dive into NATS consumer configurations. Learn how to implement Load Balanced Work Queues for scaling background jobs and Fan-Out patterns for event-driven systems.

A complete guide to replacing RabbitMQ/Kafka with NATS JetStream. Learn the core concepts of Streams, Subjects, and Consumers, and how to implement them in C#.

How we use n8n as the 'glue' code for our platform. Empowering low-code automation to handle document notifications, Telegram alerts, and system maintenance tasks.

How to run a full development environment remotely with VS Code, Kubernetes, and a persistent dev container pod.

A comprehensive guide to using Mermaid.js for creating architecture diagrams, flowcharts, sequence diagrams, and more in your technical documentation.

A comprehensive guide to configuring a modern Glassmorphism design system using Tailwind CSS v4, focusing on backdrop filters, noise textures, and maintaining accessibility.

Stop memory leaks and race conditions. Master Blazor Server's lifecycle events and build a robust BaseComponent.

Mastering JavaScript Interop in Blazor: Efficiently calling JS from C# and vice-versa, managing object references, and ensuring type safety.

Build robust forms in Blazor. Master FluentValidation integration, custom input components, and complex state management.

Implement self-hosted Single Sign-On (SSO) for Blazor Server using Authelia and OpenID Connect (OIDC).

Create a modern, translucent UI library with Blazor and Tailwind CSS 4. Master backdrop-filter, OKLCH colors, and reusable Razor components.

A comprehensive guide to adopting Tailwind CSS 4 in Blazor, leveraging CSS-first configuration and the new JIT engine for a streamlined frontend workflow.

Why we chose the Document Model and RavenDB's impressive GUI, despite the challenges of a smaller ecosystem and specialized hosting requirements.

Decoupling frontend and backend tests by defining API contracts. How we verify Blazor/FastEndpoint compatibility in CI/CD without integration environments.

Build reliable integration tests for .NET applications using Testcontainers, WebApplicationFactory, and real database instances.

Implement comprehensive health checks for .NET applications with database, cache, and dependency monitoring for Kubernetes deployments.

Implement reliable background job processing with hosted services, channels, and distributed task queues in .NET applications.

Data integrity in high-traffic applications relies on how you handle concurrent updates. We compare DB locks (Pessimistic) against Row Versioning (Optimistic) in EF Core.

Caching is easy; invalidation is hard. Move beyond simple TTL (Time To Live) and learn how to implement precise, event-driven cache busting using Redis and NATS.

Implement distributed and in-memory caching patterns in .NET applications for improved performance and reduced database load.

Implement robust error handling with Result patterns, global exception handling, and Polly resilience policies in .NET applications.

How to safely migrate from a monolithic ASP.NET MVC app to modern microservices using the Strangler Fig Pattern and YARP (Yet Another Reverse Proxy).

Achieve 100% reliable messaging by atomically committing state changes and events. A deep dive into the Outbox Pattern with EF Core and NATS utilizing background relay workers.

Separating reads from writes doesn't have to be complicated. Learn how to implement a practical CQRS architecture using FastEndpoints for the API and MediatR for clean command handling.

Manage database schema evolution with EF Core migrations, including multi-environment strategies and zero-downtime deployments.

A complete walkthrough from Event Storming to Code: Defining Aggregates, writing Entities, and exposing them via APIs. Seeing the big picture in .NET.

Why we moved from standard UUIDs to NanoIDs for primary keys: URL aesthetics, database considerations, and a custom alphabet implementation.

Ditch bloated controllers. Build high-performance, maintainable APIs using the Request-Endpoint-Response (REPR) pattern with FastEndpoints.

Decouple your domain logic from EF Core. Learn how to implement Repositories for DDD Aggregates with strict interface separation.

Master domain events in C# to build reactive systems with loose coupling, eventual consistency, and clean separation of concerns.

Learn how to design aggregates that enforce business invariants, manage consistency boundaries, and encapsulate complex domain logic in your C# applications.

Learn how to implement value objects with built-in validation, equality semantics, and EF Core persistence for a cleaner, more expressive domain model.

Stop creating invalid objects. Learn how to use static factory methods and private constructors to ensure DDD entities are always in a valid state.

Implementation of the Shared Kernel pattern: A crucial library containing the base building blocks (Entity, AggregateRoot, ValueObject) for Domain-Driven Design.

Exploring the highs of global distribution and the lows of execution limits. A candid look at when to embrace Cloudflare Workers and when to stick with containers.

Stop running as root. Build secure, minimal container images for .NET applications using multi-stage builds and distroless/alpine bases.

Safely exposing internal services to the internet without opening inbound ports using cloudflared and Zero Trust access policies.

Implement fine-grained access control with Kubernetes RBAC, service accounts, and least-privilege security patterns.

Implement network segmentation and micro-segmentation in Kubernetes using Network Policies for defense in depth.

Host your own OIDC/OAuth2 Identity Provider with Authelia on Kubernetes. Secure your apps with 2FA, SSO, and fine-grained access control.

Elevating PKI security by moving the Root CA private key to a YubiKey hardware token, ensuring the most critical secret never creates a persistent footprint on disk.

A step-by-step guide to bootstrapping a private PKI, from generating a Root CA to signing leaf certificates for internal microservices using OpenSSL.

A comprehensive guide to securing PostgreSQL in a production environment, covering pg_hba.conf, enforced SSL/TLS, RBAC, Row-Level Security (RLS), and credential management with Infisical.

Implementing 'Never Trust, Always Verify' in Kubernetes using Linkerd for mTLS, OIDC for user identity propagation, and Workload Identity for secure service communication.

Synchronize secrets from Infisical to Kubernetes using External Secrets Operator for GitOps-friendly secret management.

Manage Kubernetes configurations across environments with Kustomize overlays, patches, and ConfigMap generators.

Build robust CI/CD pipelines with GitHub Actions for .NET applications including testing, Docker builds, and Kubernetes deployment.

Learn how to implement GitOps for your Kubernetes cluster using Flux CD, including repository structure, Kustomize overlays, and automated image updates.

Deploy Longhorn for persistent distributed block storage in Kubernetes with replication, snapshots, and disaster recovery.

Stop manually renewing certificates. Set up Cert-Manager to automate Let's Encrypt DNS-01 challenges with Cloudflare.

Configure Traefik as your Kubernetes ingress controller with TLS termination, middleware chains, and IngressRoutes for routing traffic.

Deploy and configure MetalLB for load balancing in bare metal Kubernetes clusters with L2 and BGP modes.

Benchmarking storage tiers for our homelab. Why databases need local NVMe paths while object storage thrives on the NAS.

Securely exposing K8s services like API, MinIO, and databases using Tailscale sidecars and subnet routers for seamless access from anywhere.

A comprehensive guide to hardening your homelab environment using ufw, network segmentation with VLANs, and SSH key-based authentication.

A comprehensive guide to the hardware powering our homelab. From Ryzen processors and 128GB RAM to configuring TrueNAS Scale for Kubernetes storage via iSCSI and NFS.

Why we abandoned the cloud for bare metal. A deep dive into the cost savings, performance gains of 10GbE, and total data sovereignty of running on-premise.