Blog

How cybersec_dashboard packages API and UI deployment with Kubernetes manifests, ServiceMonitor integration, and OTEL/Loki-ready telemetry.

How cybersec_dashboard uses a WebSocket event bridge to stream runtime status from the async engine to the Next.js operations dashboard.

How cybersec_dashboard frames parameter-efficient training for security workloads and where LoRA or QLoRA fit in resource-constrained environments.

How the inference pipeline in cybersec_dashboard balances throughput and responsiveness with batching and TTL cache controls.

How cybersec_dashboard tokenizes packet data into model-ready representations and why this design matters for transformer-based traffic analysis.

How analyzer modules in cybersec_dashboard combine heuristic, signature, and ML-oriented signals into actionable security events.

A practical look at how network, memory, logs, registry, and process collectors are structured and coordinated in cybersec_dashboard.

How the core planner-worker-pipeline architecture in cybersec_dashboard enables async security analysis across diverse telemetry streams.

How the management backend and frontend in rpi_kubernetes evolved into an operational control plane with explicit RBAC and observability wiring.

A postmortem-style walkthrough of the Grafana port 3000 conflict in rpi_kubernetes and the scripted recovery path.

How mDNS, health monitoring, and k3s agent recovery scripts reduced cluster fragility in the Raspberry Pi environment.

How the CDC sync workflow in rpi_kubernetes handles incremental extraction and what to harden for reliable long-running operation.

How the vector sync pipeline in rpi_kubernetes coordinates chunking, embedding, and dual vector-store writes with audit logging.

How the website grew from portfolio pages into a long-form documentation and notes surface.

How rpi_kubernetes uses Dagster for control and lineage while delegating heavyweight transforms to Argo WorkflowTemplates.

How the raw ingest workflow template in rpi_kubernetes moves source data into immutable MinIO paths for downstream processing.

A practical debugging guide from rpi_kubernetes on why Argo Workflows can surface missing Argo Events CRDs and how to fix it cleanly.

How templates make assistant deployment repeatable across projects.

A practical deployment story for Dagster in rpi_kubernetes using Helm values, secrets, user-code images, and OTEL hooks.

What changed when RAGFlow was added to rpi_kubernetes and how it fits into the existing Postgres, MinIO, Redis, and search stack.

How DataHub integration in rpi_kubernetes evolved with ingestion cronjobs, bridge configmaps, and Iceberg-oriented governance patterns.

How LoRA, QLoRA, RLHF, and DPO fit into the assistant project as optional capability.

How the root kustomization in rpi_kubernetes evolved into a full multi-service platform spanning data, MLOps, and observability.

How the Nemotron coding assistant workflow evaluates local fine-tunes with practical coding benchmarks and code-quality metrics.

A practical walkthrough of the Nemotron coding assistant configuration and how to tune dataset, method, and serving settings for local training.

Why the assistant project keeps documentation and operations in separate frontends.

How the Agentic Assistants control panel exposes Dagster through dedicated routes for status, code iteration, and job operations.

A closer look at how the Dagster API in Agentic Assistants handles local import gaps and external GraphQL fallback paths.

How Dagster was integrated as an orchestration control plane across API, adapters, runners, and the WebUI in Agentic Assistants.

Why traces, MLflow, and run metadata belong in local assistant workflows.

How typed node definitions and property panel warnings keep visual model design safer in the Agentic Assistants architecture builder.

How the architecture API in Agentic Assistants stores graph definitions and exports runnable PyTorch or TensorFlow model skeletons.

A deep dive into the architecture canvas implementation in Agentic Assistants and how drag-and-drop model composition was wired in the WebUI.

What we learned from removing Langflow from optional extras due to cachetools conflicts with MLflow and how to handle similar packaging tradeoffs.

How numbered notebooks turn a broad assistant framework into a learning path.

A practical look at the WebUI dependency updates in Agentic Assistants and how they unlocked richer model and pipeline interactions.

Why the extras layout in pyproject.toml became an architectural tool, not just a packaging convenience, in Agentic Assistants.

Why the assistant framework ships starters for RAG, memory, repo intelligence, and augmentation.

How to use the RAG Eval Playground starter to move from anecdotal prompting to measurable retrieval and answer quality.

How the Repo Intel Hub starter operationalizes repository ingestion for local retrieval workflows with repeatable config and scheduling patterns.

A practical guide to selecting the right Agentic Assistants starter based on latency, memory, retrieval quality, and operational complexity.

How coding helper, framework guide, and meta analyzer modes serve different jobs.

How the Agentic Assistants examples library uses Poetry extras to keep installs lightweight while still supporting a broad set of workflows.

Design decisions behind the Agentic Assistants examples library and why the 42-topic layout scales better than a single giant demo.

How local file discovery becomes cataloged data instead of a one-off scan.

How Kedro-style pipelines keep assistant data processing understandable.

How the assistant framework thinks about vector stores and local metadata.

How repository indexing turns local files into assistant context.

How the assistant server exposes chat, search, sessions, and tool-like integration.

How the agentic CLI became the reliable entry point for config, indexing, discovery, and templates.

Why Agentic Assistants centers local models, local indexes, and private context.

Why paper sessions share broker, data, queue, strategy, and risk concepts with live trading.

How external open-source ideas are adapted into platform-native assets.

How the Next.js UI organizes agents, RAG, data, ML, bots, and streaming into workflows.

How task progress shapes the usability of long-running research workflows.

Why Kafka, Flink, producers, and links need a management layer.

Deploying ML models as production-ready API endpoints on a Raspberry Pi cluster using BentoML for packaging and Yatai for lifecycle management.

How model training, deployment, and backtesting become one experiment.

Why CFPB, FDA, and USPTO corpora belong in a quant research platform.

Automating Raspberry Pi cluster provisioning with Ansible playbooks, shell scripts, and PowerShell -- bridging Linux nodes and Windows workstations.

How first-, second-, and third-order corpora shape the platform's retrieval design.

The journey from local Docker Compose development to production Kubernetes deployment for the Agentic Assistants framework.

Implementing experiment tracking, model registry, and distributed tracing for ML workloads using MLFlow and OpenTelemetry.

How TradingBot and ResearchBot tie together strategies, engines, ML, agents, RAG, and deployment.

Designing and building a web-based control panel for monitoring and managing a Raspberry Pi Kubernetes cluster.

The operational reason for routing spec-driven agents through AgentRuntime.

A deep dive into the local coding assistant example -- RAG over codebases, episodic memory with mem0, and Redis solution caching.

How multiple backtest engines can coexist without leaking into every caller.

A detailed write-up of the [Project Name] project -- architecture, implementation, and lessons learned.

A detailed technical walkthrough of [topic]. Replace this with your actual description.

An introduction to my technical blog -- who I am, what I work on, and what you can expect to find here.

Why strategies, models, and engines use class/module/kwargs configuration.

Building a full observability stack on a Raspberry Pi Kubernetes cluster with OpenTelemetry Collector, Jaeger, VictoriaMetrics, and Loki.

How the Agentic Assistants cybersecurity example uses AI agents for red/blue team operations, vulnerability scanning, and log analysis.

Why the platform separates table storage from local analytical execution.

Building reproducible data pipelines using Kedro-inspired catalog patterns, orchestrated with Dagster and Prefect.

How API requests become durable quant platform work.

Comparing ChromaDB and Milvus for vector search on resource-constrained Raspberry Pi 5 nodes -- when to use each and how to deploy them.

The privacy and iteration reasons behind keeping data, alpha research, and agent runs local.

How Agentic Assistants implements reinforcement learning from human feedback using TRL, with support for DPO, PPO, ORPO, and KTO.

Why cost and ownership labels still matter on a home Kubernetes platform.

Setting up MLFlow for experiment tracking, Dask for distributed data processing, and Ray for distributed compute on a Raspberry Pi 5 cluster.

Why paused CronJobs and bootstrap jobs belong in the deployment story.

A practical walkthrough of fine-tuning LLMs locally using LoRA, QLoRA, and Llama Factory within the Agentic Assistants framework.

How document workflows fit beside the Kubernetes and data services.

How to use mDNS/Avahi for zero-configuration node discovery in a Raspberry Pi Kubernetes cluster -- no static IPs required.

Building a useful observability stack with Prometheus, Grafana, Loki, Vector, Jaeger, and OpenTelemetry.

How Agentic Assistants uses the adapter pattern to support CrewAI and LangGraph as interchangeable multi-agent backends.

How the Alpha Vantage integration grew from a script into a cluster workload.

A complete guide to building a 4-node Raspberry Pi 5 Kubernetes cluster with k3s and an Ubuntu desktop as a hybrid control plane.

Why the cluster management API became a thin operational layer over Kubernetes services.

An overview of the Agentic Assistants framework -- a local-first platform for multi-agent AI, custom LLM training, and MLOps.

How catalog, ingestion, and Iceberg-facing services fit into the homelab.

How PyFlink and Java TA-Lib jobs fit different parts of the streaming workflow.

What Strimzi and Kafka teach on constrained ARM workers.

Why Redis Stack became the cache, vector, and document-adjacent primitive in the cluster.

The production edge design for julianwiley.com on the homelab cluster.

How the root kustomization became the map of the homelab platform.

The practical role of mDNS and node discovery in a home Kubernetes cluster.

Why the cluster uses an Ubuntu desktop control plane with Raspberry Pi 5 workers.

How the Raspberry Pi cluster shifted from a k3s experiment into a small data and ML platform.