Forem: PeterMilovcik

Create a Domain Driven Design custom agent for GitHub Copilot

PeterMilovcik — Mon, 15 Dec 2025 08:03:44 +0000

This tutorial shows how you create and use a reusable GitHub Copilot custom agent focused on Domain Driven Design for .NET.
You end with one small agent file.
You reuse the agent across repositories.
You guide Copilot toward clean DDD decisions.

Why use a DDD custom agent

Copilot follows context.
Without guidance, design quality drifts.

A custom agent gives Copilot a stable role:

Enforces DDD boundaries
Protects domain purity
Pushes behavior driven models
Promotes test first thinking

You stop repeating architectural rules.
You focus on business problems.

Prerequisites

Visual Studio Code 1.106 or newer
GitHub Copilot enabled
GitHub Copilot Chat enabled

Custom agents ship with recent VS Code releases.

What this agent enforces

The agent acts as a DDD expert for .NET projects.

Core principles:

Clear bounded contexts
Ubiquitous language aligned with code
Pure Domain layer
Explicit Application layer orchestration
Infrastructure isolated behind ports
Strong domain and integration tests

Step 1: Create a custom agent

Open VS Code
Open GitHub Copilot Chat
Open the agents dropdown
Select Configure Custom Agents
Select Create new custom agent

You now choose a location.

Location options

User profile

Reuse across all repositories
Best choice for personal workflows

Workspace

Stored inside repository
Best choice for team sharing

For team usage, select workspace.

Step 2: Add the agent file to the repository

Create this folder if missing:

.github/agents

Create a file:

ddd.agent.md

Step 3: Paste the DDD agent definition

---
name: DDD
description: Domain-Driven Design (DDD) expert for .NET
tools: ['edit', 'runNotebooks', 'search', 'new', 'runCommands', 'runTasks', 'microsoft.docs.mcp/*', 'usages', 'vscodeAPI', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo', 'extensions', 'todos', 'runSubagent', 'runTests']
---
You are a Domain-Driven Design expert for .NET (C#). Optimize for correctness and maintainability.

Non-negotiables
- Identify bounded context and ubiquitous language from the repo. Ask if unclear.
- Keep Domain pure. No infrastructure, UI, transport, persistence, logging, or framework dependencies in Domain code.
- Model behavior first. Entities (identity), Value Objects (immutable), Aggregates (consistency boundary), Domain Events (facts).
- Only the aggregate root is referenced from outside. Only mutate aggregate state via root methods which enforce invariants.
- Define application use cases in an Application layer. Orchestrate workflows, authorization, transactions, and coordination there.
- Define ports as interfaces near the Domain or Application boundary. Implement adapters in an Infrastructure layer.
- Persistence concerns live outside Domain. Use mapping or configuration code in Infrastructure to keep Domain persistence-ignorant.
- Testing: domain unit tests for invariants and behaviors, integration tests for adapters and persistence mappings, run tests after edits.

Workflow
1) Read relevant code and constraints.
2) Propose a short plan.
3) Implement with smallest safe change-set.
4) Add or update tests.
5) Run tests and fix failures.

Response format
- Questions or Assumptions
- Plan
- Changed files
- Tests to run
- Notes or Risks

Save the file.
Commit the file if using a shared repository.

Step 4: Activate the agent

Open GitHub Copilot Chat
Open the agents dropdown
Select DDD

Copilot now operates under strict DDD rules.

Step 5: Work with the agent

Write requests in domain language.
Avoid technical framing in prompts.

Example 1: Aggregate design

Introduce an Order aggregate.
Move invariants into named methods.
Add domain unit tests.

Expected outcome:

Aggregate root creation
Invariants enforced inside methods
Tests validating business rules

Example 2: Bounded context split

Identify bounded contexts for Billing and Shipping.
Propose folder structure.
Hide cross context calls behind ports.

Expected outcome:

Context boundaries
Clear namespaces
Explicit interfaces between contexts

Example 3: Domain events

Add OrderSubmitted domain event.
Raise event from aggregate root.
Add application handler and tests.

Expected outcome:

Event raised inside domain logic
Handler placed in application layer
Tests covering behavior

What changes after adoption

Less anemic models
Fewer leaking dependencies
Smaller pull requests
Cleaner tests
Faster design reviews

Copilot stops guessing architecture.
Copilot follows rules.

Recommended usage pattern

Select DDD agent before architectural changes
Switch back to default agent for trivial edits
Keep agent file stable
Review changes through DDD lens

Next improvements

Optional follow ups:

Separate agent for persistence adapters
Separate agent for testing strategy
Team wide instruction file for baseline rules

The DDD agent stays small.
The impact stays large.

Reusable GitHub Copilot Prompt for Implementation Plans

PeterMilovcik — Sat, 06 Dec 2025 07:47:41 +0000

Large edits from GitHub Copilot Agent often feel risky.
You ask for a change and the agent starts to rewrite files.
Only later you notice hidden side effects.

A small reusable prompt file reduces this risk.
You ask for a plan first.
You approve the plan.
Then the agent edits code.

This article walks through one prompt file named implementation_plan.prompt.md which supports this workflow.

The prompt file

Create folder .github/prompts in your repository if no such folder exists.

Add file:

.github/prompts/implementation_plan.prompt.md

Use this content:

---
agent: agent
---
Before making any changes, prepare a detailed step by step implementation plan with numbered actions, files to edit, reasoning for each change, identified risks, and example code snippets for key parts. Ask clarifying questions if anything in my request is unclear. Present this plan for review and wait for my approval before starting.

Front matter selects the agent which runs this prompt.
Text below describes response format and behavior.

What this prompt enforces

The instruction asks for several concrete elements.

Numbered actions

You receive ordered steps.
You see how the agent plans to approach the work.
You choose where to stop or split the plan.

Files to edit

The response lists target files.
You see scope before any edit.
You spot sensitive areas early.

Reasoning for each change

The agent explains why each step exists.
You compare reasoning with your own intent.
You catch misunderstandings before they reach code.

Identified risks

The agent points out risky parts of the plan.
For example, shared components or public APIs.
You add constraints or ask for a safer approach.

Example code snippets

The response includes small examples for key parts.
You review structure and style early.
You align patterns with project standards.

Clarifying questions

The prompt asks the agent to raise questions when something feels unclear.
This steers the session toward a short dialogue instead of blind action.

Approval gate

The last sentence requests a pause before edits.
The agent proposes a plan.
You respond with approval or changes.
Only then the next step starts.

Using the prompt in GitHub Copilot Chat

Work with this prompt in a simple way.

Open GitHub Copilot Chat.
Write your request and list the changes you want, with any #file: references you prefer.
Add /implementation_plan at the end of your message on a new line.
Send the message.

Example:

I want to extract discount logic from OrderService into a separate domain service.
Keep behavior stable for all callers.
Focus on smaller methods and clearer error handling.

/implementation_plan

GitHub Copilot Agent reads your description together with the reusable prompt.
The response follows the structure you defined in implementation_plan.prompt.md.

You then review the plan.
You ask for adjustments or extra focus where needed.
After you feel confident, you ask the agent to start with concrete edits in a follow up message.

Refactoring example

A short scenario from daily work.

You see complex method logic in a service class.
You open Copilot Chat.
You send:

Refactor the main billing method in BillingService into smaller methods.
Keep business behavior unchanged.
Point out places where error handling needs improvement.

/implementation_plan

The agent replies with a plan such as:

Steps for scanning existing logic
Plan for extracting helper methods
List of new private methods or new classes
Risk notes around behavior changes and existing integrations
Sample code for the new structure

You respond with comments like:

Keep the public interface unchanged
Avoid changes in logging behavior
Add a step for updating related unit tests later

The agent updates the plan and sends a new version.
Only when you confirm, the session moves on to actual edits.

Team benefits

This pattern improves collaboration with GitHub Copilot Agent.

Shared expectations

Each developer on the team uses the same prompt file.
New team members learn a stable way to work with AI assistance.

Lower review overhead

Pull requests show changes which follow an agreed plan.
Reviewers read the original plan in chat history when they need context.

Less accidental scope creep

The plan defines scope clearly.
You notice when the agent tries to do too much in one go.

Clear structure for larger changes

Complex refactors break into smaller, named steps.
You run these steps in order and keep control.

Variations

Adapt this idea for different kinds of work.

For destructive tasks such as file removal, tighten wording around confirmation.
For experimental branches, relax constraints.
For production critical services, add a step for rollback ideas.

Each variation lives in its own prompt file under .github/prompts, for example:

security_review.prompt.md
performance_review.prompt.md
migration_plan.prompt.md

Every file follows the same pattern.
Front matter at the top.
Concise instruction in the body.

Start using the prompt

Add implementation_plan.prompt.md to your repository.
Use this helper for the next feature or refactor.
Observe how your sessions with GitHub Copilot Agent change.

You spend more time judging plans and less time fixing surprises.

Reusable GitHub Copilot Prompt for Refactoring Opportunities

PeterMilovcik — Tue, 02 Dec 2025 10:57:12 +0000

Refactoring becomes easier when you receive fast feedback about improvement options in code.

GitHub Copilot Chat already helps with this, but writing a long prompt each time feels wasteful.

A small prompt instruction file in your repository removes friction.

This article walks through one concrete example.

What is a prompt instruction file

GitHub Copilot Chat supports reusable prompts stored under a .github/prompts folder in your repository.

Each file holds instructions for the agent.

You reference such a file from chat with a slash command instead of copying full text again.

This section focuses on one refactoring helper prompt.

Step 1: Create the prompt file

Create folder .github/prompts in your repository if it does not exist yet.

Add a new markdown file named refactoring_opportunities.prompt.md inside this folder.

Use the following content.

---
agent: agent
---

Check for potential refactoring opportunities in the following code. If you find any, suggest specific improvements along with code examples. Focus on enhancing readability, maintainability, and performance. If the code is already optimal, simply state that no changes are necessary.

A short explanation:

The front matter at the top selects which agent runs this prompt.
The text below tells Copilot Chat what to look for and how to respond.

Step 2: Use the prompt from chat

Open GitHub Copilot Chat in your editor.

Use this command:

/refactoring_opportunities #file:<yourfile>

Replace <yourfile> with the file name you want to inspect, for example:

/refactoring_opportunities #file:MyClass.cs

Copilot receives code from this file together with prompt text from refactoring_opportunities.prompt.md.

The agent then reviews the code and responds with suggested refactorings or a short confirmation when nothing needs to change.

What this prompt asks for

The instruction focuses on three aspects.

Readability
Names, structure, and formatting should help new readers understand code quickly.
Maintainability
Smaller functions, clear responsibilities, and fewer hidden dependencies reduce effort for future changes.
Performance
The agent points out unnecessary allocations, redundant work, and obvious algorithm problems.

The last sentence in the prompt keeps responses grounded.

When no clear improvement appears, Copilot replies with a short message instead of forcing weak suggestions.

Noise in your review process stays low.

Why store the prompt in your repository

Keeping prompt files inside version control brings a few benefits.

Shared language for the team
Everyone calls the same prompt name and receives similar guidance.
History
You refine wording through pull requests and review changes together.
Portability
Prompt files travel with the codebase, so new team members gain useful helpers from day one.

A prompt becomes part of your engineering practice, not a snippet lost in chat history.

Ideas for extensions

Once refactoring_opportunities.prompt.md works, expand with more prompt files in the same folder.

Some examples:

security_review.prompt.md for quick checks of obvious security problems.
test_gaps.prompt.md for simple suggestions where tests might be missing.
api_consistency.prompt.md for checks of naming and behavior across endpoints and clients.

Each file follows the same pattern.

Front matter selects an agent, body text explains the task.

Summary

A small prompt instruction file turns GitHub Copilot Chat into a repeatable refactoring assistant.

You spend less time writing prompts and more time judging suggestions.

Start with refactoring_opportunities.prompt.md under .github/prompts, then call:

/refactoring_opportunities #file:YourFile.cs

whenever you want a fresh look at a piece of code.

One GitHub Copilot Agent Prompt for Safer Changes

PeterMilovcik — Tue, 02 Dec 2025 07:51:05 +0000

Developers like automation. GitHub Copilot Agent writes code, runs tests, edits files.

This speed hides a risk. The agent starts changing code before you see a plan.

You need a brake. A short sentence in your prompt gives you control.

The core idea

Describe the changes you want.

Then finish your prompt with this line:

Before you do any changes, show me your detailed step by step implementation plan for approval.

You ask the agent for a plan first. No edits yet. Only a clear list of steps.

Afterwards you review the plan. You confirm, refine, or reject.

Why this helps

A plan first pattern improves the flow.

You gain:

Clear intent before edits touch your code
Easier review, since you see a list of steps, not a block of diff
Lower risk of half-finished refactors

The agent shifts from "fire and forget" to "propose, then act".

You stay in charge of scope and direction.

A small example

Prompt:

I want to extract logging concerns from this C# class into a separate service.

Steps:
1. Identify all logging calls.
2. Introduce an IAppLogger interface.
3. Inject IAppLogger into the constructor.
4. Replace direct logging calls with the new abstraction.

Before you do any changes, show me your detailed step by step implementation plan for approval.

A good plan from the agent might look like this:

Step 1: Scan the class and list all logging calls, grouped by log level.
Step 2: Propose the IAppLogger interface signature which covers the current usage.
Step 3: Add the new interface and a concrete implementation in a Logging folder.
Step 4: Update the target class constructor to accept IAppLogger through dependency injection.
Step 5: Replace direct logging calls with calls to IAppLogger.
Step 6: Update the composition root to register the concrete logger.
Step 7: Propose unit test updates for the new abstraction.

You read the plan. You notice missing points or risks.

For example:

No mention of structured logging
No mention of log context
No mention of cross cutting concerns in other classes

You respond:

Good start.

Extend the plan with:
- Structured logging support
- Log context (correlation id, user id)
- Follow up steps for other classes using logging in this project

Then show me the updated plan. Do not change any code yet.

Only when the plan looks solid you ask the agent to apply the plan.

Prompt variants

You tune the line for different work modes.

For safety and review:

Before you do any changes, show me your detailed step by step implementation plan for approval. Wait for my confirmation before you start.

For pair programming:

Before you do any changes, propose a detailed step by step implementation plan. Ask me questions if anything in my request is unclear.

For larger refactors:

Before you do any changes, outline a detailed step by step implementation plan with milestones. Mark risky steps explicitly.

Notice the common structure.

You ask for:

A detailed plan
Steps in order
A pause before edits
Space for questions

Tips for daily use

A few habits help you get value from this pattern.

Keep your change request short and focused
Ask for numbered steps
Ask for risk highlights for bigger changes
Ask for test impact in the plan
Store your favorite prompt variant in a snippet or note
Use the same pattern across your team, so prompts stay consistent

When this pattern shines

This simple line in your prompt works best when:

You refactor legacy code
You touch shared libraries
You change public APIs
You work in a codebase you do not know well
You review plans with teammates in chat or pull requests

In all those cases you gain a shared view of the work before any edit happens.

You see scope. You see risk. You see test impact.

Then you decide how far the agent should go.

You guide the agent. Not the other way around.

Integrating OpenAI's Retrieval-Augmented Generation in NET Applications

PeterMilovcik — Mon, 10 Mar 2025 10:55:01 +0000

Integrating OpenAI's Retrieval-Augmented Generation (RAG) in a .NET application involves several steps, including setting up a local embedding vector database, processing PDF documents using PdfPig, and leveraging the OpenAI SDK along with Microsoft.Extensions.AI for unified AI abstractions. Here’s a step-by-step guide to achieve this integration:

Step 1: Setup Environment

Prerequisites:

.NET 6 or higher installed.
A C# development environment (Visual Studio, VS Code, or .NET CLI).
An OpenAI API Key for accessing OpenAI services.
PdfPig for PDF text extraction.
Microsoft.Extensions.AI for unified AI abstractions.

Install Required Packages:

dotnet add package OpenAI
dotnet add package PdfPig
dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.Extensions.AI.OpenAI

Step 2: Extract Text from PDFs Using PdfPig

Extract text from PDFs to create chunks for embedding generation.

using PdfPig;

// Load PDF
using var pdfDocument = PdfDocument.Open("path/to/your/document.pdf");

// Extract text
var text = string.Join("\n", pdfDocument.GetPages().Select(p => p.GetText()));

// Split text into chunks (e.g., paragraphs)
var chunks = text.Split(new[] { "\n\n" }, StringSplitOptions.RemoveEmptyEntries);

Step 3: Generate Embeddings Using OpenAI SDK

Use the OpenAI SDK to generate embeddings for each chunk.

using OpenAI;

// Initialize OpenAI client with API key
var openAiClient = new OpenAIClient(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

// Generate embeddings for each chunk
foreach (var chunk in chunks)
{
    var embedding = await openAiClient.Embeddings.GenerateAsync(chunk, "text-embedding-ada-002");
    // Store the embedding in a local database or in-memory structure
}

Step 4: Implement Local Embedding Vector Database

Store the generated embeddings in a simple local database or in-memory structure like a dictionary.

using System.Collections.Generic;

// In-memory database example
var embeddingDatabase = new Dictionary();

// Store embeddings
foreach (var chunk in chunks)
{
    var embedding = await openAiClient.Embeddings.GenerateAsync(chunk, "text-embedding-ada-002");
    embeddingDatabase.Add(chunk, embedding.Vector.ToArray());
}

Step 5: Implement Chat Loop with Microsoft.Extensions.AI

Use Microsoft.Extensions.AI to create a chat loop that queries the local embedding database.

using Microsoft.Extensions.AI;

// Initialize chat client
var chatClient = new OpenAIClient(Environment.GetEnvironmentVariable("OPENAI_API_KEY")).AsChatClient();

// Chat loop
while (true)
{
    Console.Write("Enter your question: ");
    var query = Console.ReadLine();

    if (query == "exit")
        break;

    // Generate query embedding
    var queryEmbedding = await openAiClient.Embeddings.GenerateAsync(query, "text-embedding-ada-002");

    // Perform vector similarity search
    var similarities = embeddingDatabase.Select(kvp => (Key: kvp.Key, Similarity: CosineSimilarity(queryEmbedding.Vector.ToArray(), kvp.Value)));

    // Get top matches
    var topMatches = similarities.OrderByDescending(s => s.Similarity).Take(3);

    // Display matches
    foreach (var match in topMatches)
    {
        Console.WriteLine($"Match: {match.Key}, Similarity: {match.Similarity:F2}");
    }
}

// Cosine similarity function
float CosineSimilarity(float[] vec1, float[] vec2)
{
    var dotProduct = vec1.Zip(vec2, (a, b) => a * b).Sum();
    var magnitude1 = MathF.Sqrt(vec1.Sum(x => x * x));
    var magnitude2 = MathF.Sqrt(vec2.Sum(x => x * x));
    return dotProduct / (magnitude1 * magnitude2);
}

Step 6: Run the Application

Run the console application and interact with it by asking questions about the PDF documents.

This setup integrates OpenAI RAG with a local embedding vector database and uses PdfPig for PDF processing, all within a .NET environment enhanced by Microsoft.Extensions.AI for unified AI abstractions.

Answer from Perplexity: pplx.ai/share

Implementing RAG with Azure OpenAI in .NET (C#)

PeterMilovcik — Mon, 10 Mar 2025 10:20:59 +0000

This tutorial was created using OpenAI's Deep Research capability.

Retrieval-Augmented Generation (RAG) combines a document retrieval step with an OpenAI LLM to ground the model’s answers on your data. Below are best practices for a quick yet robust prototype in C#, focusing on storage, embeddings, vector search, and resources.

Document Storage: Azure Blob vs. Local

Use Azure Blob Storage for realistic scenarios – Storing documents in Azure Blob Storage is the recommended approach, especially if you plan to integrate with Azure Cognitive Search. Azure’s RAG tutorials upload source files (e.g. PDFs) to a Blob container so an indexer can ingest and chunk them automatically (RAG tutorial: Build an indexing pipeline - Azure AI Search | Microsoft Learn). Blob Storage is scalable and allows Azure Search or other services to pull content easily.

Local storage for quick prototyping – For a simple prototype or local development, you can read files from the local filesystem. This avoids provisioning cloud storage initially. It’s acceptable to start with local files if you have just a few documents. Keep in mind you’ll likely transition to Blob Storage for production or if you want to use Azure Search indexers (which work natively with Azure Blob). In short, local storage is fine for an isolated proof-of-concept, but Azure Blob Storage is preferred for anything beyond a toy example or when using Azure’s managed pipelines.

Authentication: In a prototype, using the storage account’s API key or connection string is easiest for access. You can supply the Blob Storage key (or a SAS token) in your configuration to let your .NET code upload or download files. This is simpler than setting up Azure AD roles at this stage. (You can later move to managed identities for better security once the basic solution works.)

Embedding Model: Choosing the Best for Azure OpenAI

Use OpenAI’s text-embedding-ada-002 model – The ADA v2 text embedding model is currently the go-to for Azure OpenAI RAG scenarios. It produces 1536-dimensional embeddings and offers strong semantic representation of text. In fact, Azure’s AI Search integration expects an embedding model like text-embedding-ada-002 for vectorization (Azure OpenAI Embedding skill - Azure AI Search | Microsoft Learn). As of now, text-embedding-ada-002 is the primary available embedding model in Azure OpenAI (other newer embedding models like “text-embedding-3-large” are in preview or not yet generally available to all users (embedding model for RAG, OpenAI Studio - Microsoft Q&A)).

Why ADA-002? It’s proven to perform well on a variety of semantic search tasks and is the recommended default. Using this model ensures your document chunks and user queries are mapped to the same vector space for meaningful similarity matching (Azure OpenAI Embedding skill - Azure AI Search | Microsoft Learn). When you create your Azure OpenAI resource, deploy the ada-002 embedding model (e.g., as an “embeddings” deployment) so your .NET app can call it. For example, you’ll call the Azure OpenAI Embeddings API with this model to vectorize your document chunks and user questions.

Vector Database: Azure AI Search vs. pgvector vs. Others

Once you have embeddings, you need a vector store to index and query them for nearest matches:

Azure AI Search (Cognitive Search) – This is often the simplest and most integrated choice for an Azure-based RAG prototype. Azure Cognitive Search now supports vector search natively, and it’s a “proven solution” for RAG in enterprise scenarios (RAG and generative AI - Azure AI Search | Microsoft Learn). You can create a search index with a vector field to store embeddings, and use the Search service’s API to perform cosine similarity searches. The benefit is that Azure Search also provides robust indexing (including built-in chunking and enrichment skills) and security controls. If your data doesn’t change frequently in real-time, and you’re okay managing an index, Azure AI Search is compelling (Choose an Azure service for vector search - Azure Architecture Center | Microsoft Learn). It offloads a lot of the heavy lifting: for instance, you can set up an indexer that automatically chunks documents and calls the embedding model to vectorize content during ingestion (RAG tutorial: Build an indexing pipeline - Azure AI Search | Microsoft Learn).
PostgreSQL with pgvector – Using a relational database can be convenient if you prefer a lightweight setup or already have a database in your stack. PostgreSQL’s pgvector extension allows you to store embedding vectors and run similarity queries via SQL. This approach is straightforward: you insert your vectors into a table and use cosine (or inner product) distance functions provided by pgvector to find nearest neighbors. If your team is already comfortable with Postgres, leveraging it might be the easiest solution for your scenario (Choose an Azure service for vector search - Azure Architecture Center | Microsoft Learn). It’s a good option for quick prototypes because you can avoid learning a new service – just add the extension to an Azure Database for PostgreSQL or local Postgres, and you have a basic vector database ready. Keep in mind performance might be lower than a specialized vector store for very large vector counts, but for moderate volumes it works well.
FAISS or other libraries – FAISS (Facebook AI Similarity Search) is a high-performance library for vector similarity search. It’s typically used in Python or C++ environments, but there are .NET bindings and alternatives (like SciSharp’s MILVus or using Pinecone via API) if you want to explore them. For a quick C# prototype, introducing FAISS might add complexity unless you’re familiar with it. However, if you need an on-premise or in-memory solution without external services, you could integrate a vector search library. Many RAG prototypes skip a database entirely and just use an in-memory list of vectors with a brute-force cosine similarity for simplicity when the data size is very small – this is not scalable, but can jumpstart a proof-of-concept.

Recommendation: For an Azure-oriented prototype, Azure Cognitive Search is often the best blend of simplicity and capability. It’s managed, requires minimal code for indexing/querying, and ties in nicely with Azure OpenAI (for example, Azure’s “OpenAI on your data” feature can use an Azure Search index as the knowledge source). If you prefer not to provision Azure Search or want everything local, Postgres/pgvector is a solid fallback that keeps things simple while following best practices (vector indexing in a database). In contrast, FAISS or dedicated vector DBs (Pinecone, Weaviate, etc.) might be overkill for a quick demo unless you specifically want to evaluate them. The bottom line is that any vector store can work – RAG isn’t limited to one technology (AI Architecture Design - Azure Architecture Center | Microsoft Learn) – so choose the one that lets you iterate fastest while meeting your needs.

Authentication with API Keys (Azure OpenAI & Storage)

For a quick prototype, API key-based authentication is the way to go. Both Azure OpenAI and Azure Storage support API keys that you can use in your .NET application, avoiding the overhead of Azure AD authentication setup. Using the keys is straightforward and gets you up and running quickly. Microsoft’s documentation notes that while you can use Azure AD roles for tighter security, “keys are easier to start with” for development (Quickstart: Generative Search (RAG) - Azure AI Search | Microsoft Learn).

In practice, this means:

Azure OpenAI – Use the Key and Endpoint from your Azure OpenAI resource. For example, when calling the Azure OpenAI REST API (or SDK), set the api-key header with your key. In C#, if using the OpenAI client libraries or REST calls, ensure you include the key. (Azure OpenAI also requires an API version in the endpoint URL.)
Azure Storage (Blobs) – Use the storage account key or a SAS token to authenticate your Blob client in Azure SDK for .NET. For instance, you can use new BlobServiceClient(<connection_string>) where the connection string contains the key. This avoids needing to configure managed identities or OAuth in a prototype.

Using API keys for both services will let your prototype run with minimal friction. Just be sure to keep the keys safe (don’t hard-code them in public code; use something like user-secrets or environment variables in your .NET project). You can later swap to managed identities when moving toward production, but for now API keys are perfectly fine and conform to Azure’s recommended quickstart practices (Quickstart: Generative Search (RAG) - Azure AI Search | Microsoft Learn).

Official Microsoft Tutorials & Resources

Microsoft provides several tutorials and examples to guide you in building a RAG solution on Azure:

Azure Learn RAG Tutorial Series – The Azure Cognitive Search documentation has an end-to-end RAG tutorial series. For example, there’s a Quickstart: Generative search (RAG) guide that shows how to set up an Azure AI Search index and query it with Azure OpenAI. “In this quickstart, you send queries to a chat completion model for a conversational search experience over your indexed content on Azure AI Search” (Quickstart: Generative Search (RAG) - Azure AI Search | Microsoft Learn). It walks through setting up the services (OpenAI, Search) and using them together (the sample code is in Python, but the concepts apply equally to .NET). There are also Azure Architecture Center articles on designing RAG solutions, and a tutorial on building an indexing pipeline that covers chunking, embedding, and indexing documents (RAG tutorial: Build an indexing pipeline - Azure AI Search | Microsoft Learn).
“ChatGPT + Enterprise Data” C# Sample – Microsoft has an official .NET sample on GitHub (Azure-Samples) that demonstrates a full RAG application using Azure OpenAI and Azure Cognitive Search. “This sample… uses Azure OpenAI Service to access the ChatGPT model, and Azure AI Search for data indexing and retrieval.” (GitHub - Azure-Samples/azure-search-openai-demo-csharp: A sample app for the Retrieval-Augmented Generation pattern running in Azure, using Azure Cognitive Search for retrieval and Azure OpenAI large language models to power ChatGPT-style and Q&A experiences.). It’s a Blazor web app that allows you to ask questions to an internal knowledge base. The repo comes with scripts to set up Azure Blob Storage (for documents), an Azure Search index, and Azure OpenAI deployments. This is a great resource to see best practices in action (chunking docs, storing embeddings in the index, constructing prompts with citations, etc.) in a C# codebase. You can deploy it to Azure or run locally once you configure the keys.
Microsoft Learn Modules – Look for learning modules or workshops on “Azure OpenAI and Cognitive Search”. For instance, Azure AI Search’s documentation includes an overview of RAG and suggests approaches in different languages. They even mention templates for .NET that create an end-to-end solution (RAG and generative AI - Azure AI Search | Microsoft Learn). Additionally, the AI Show or Azure webinars often showcase building a chatbot with your own data on Azure. Checking Microsoft Learn for “OpenAI on your data” or “knowledge mining with Azure OpenAI” can yield step-by-step content.

By leveraging these resources, you can follow a proven path. Start by uploading a few documents to Blob (or using provided sample data), create a vector index (either via Azure Search or manually with pgvector), obtain embeddings with Ada-002, and then use the OpenAI GPT-35-Turbo or GPT-4 model to answer questions with the retrieved content. The tutorials will reinforce the best practices: store data securely, use efficient embedding models, query via vector similarity, and authenticate with API keys for simplicity.

Sources:

Azure Cognitive Search RAG Tutorial – “This exercise uploads PDF files into blob storage for automated indexing.” (RAG tutorial: Build an indexing pipeline - Azure AI Search | Microsoft Learn)
Azure OpenAI Embeddings – Use an embedding model such as text-embedding-ada-002 (Azure OpenAI Embedding skill - Azure AI Search | Microsoft Learn)
Azure AI Search for Vector Data – Azure AI Search is a proven solution for information retrieval in a RAG architecture… providing indexing and query capabilities with Azure’s infrastructure. (RAG and generative AI - Azure AI Search | Microsoft Learn)
Choosing a Vector Store – If you already use a specific type of database… using that same type might be the easiest solution… each service has unique capabilities and limitations for vector search. (Choose an Azure service for vector search - Azure Architecture Center | Microsoft Learn)
Azure Search + OpenAI Sample (C#) – This sample… uses Azure OpenAI Service (ChatGPT) and Azure AI Search for data indexing and retrieval. (GitHub - Azure-Samples/azure-search-openai-demo-csharp: A sample app for the Retrieval-Augmented Generation pattern running in Azure, using Azure Cognitive Search for retrieval and Azure OpenAI large language models to power ChatGPT-style and Q&A experiences.)
Azure OpenAI Quickstart Note – “You can use API keys or roles… Keys are easier to start with.” (Quickstart: Generative Search (RAG) - Azure AI Search | Microsoft Learn)

Photo by Pachon in Motion

How to Integrate OpenAI for Text Generation, Text-to-Speech, and Speech-to-Text in .NET

PeterMilovcik — Thu, 07 Nov 2024 19:10:20 +0000

With the release of OpenAI's latest NuGet package (version 2.0.0), developers can easily integrate AI-driven text generation, text-to-speech (TTS), and speech-to-text (STT) functionalities into their .NET applications. This guide will walk through creating an OpenAI service in .NET that allows you to generate text responses, convert text to audio, and transcribe audio files back to text.

This implementation will use the minimum configuration necessary. For Windows, we’ll also leverage the NAudio package for handling audio playback, as it offers a straightforward solution for recording and playing audio files.

Prerequisites

Before you start integrating OpenAI’s capabilities into your .NET project, make sure you have the following set up:

Install the OpenAI NuGet Package (Version 2.0.0): Add the latest version of the OpenAI NuGet package to your .NET project:

dotnet add package OpenAI --version 2.0.0

Install NAudio (for Windows audio handling): If you're working on a Windows machine and need to handle audio recording or playback, add the NAudio NuGet package:

dotnet add package NAudio

Set the OpenAI API Key:
- For Windows users, you can set the OPENAI_API_KEY environment variable using the Command Prompt:

setx OPENAI_API_KEY your_openai_api_key

Note: Run this command in a Command Prompt with administrative privileges for a system-wide setting.
Restart any open Command Prompt or PowerShell windows after running this command to ensure the new variable is recognized.
For other platforms (macOS, Linux), you can set the environment variable using:

export OPENAI_API_KEY=your_openai_api_key

Ensure .NET SDK is Installed: Make sure you have the latest version of the .NET SDK installed. You can check your version using:

dotnet --version

With these prerequisites in place, you are ready to start building AI-enhanced features into your .NET applications!

Step 1: Generating Text Responses

The following OpenAiService class uses OpenAI’s text generation API, powered by the GPT-4 model, to generate responses based on a given prompt.

public class OpenAiService
{
    private readonly ChatClient _chatClient;

    public OpenAiService()
    {
        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
        _chatClient = new ChatClient("gpt-4o-mini", apiKey);
    }

    public async Task<string> GenerateResponseAsync(string prompt)
    {
        var messages = new List<ChatMessage>
        {
            new SystemChatMessage("You are a knowledgeable assistant."),
            new UserChatMessage($"Generate a response based on the prompt:\n\n{prompt}")
        };
        var completion = await _chatClient.CompleteChatAsync(messages);
        return completion.Content[0].Text;
    }
}

In this class:

The GenerateResponseAsync method takes a prompt and generates a response.
We initiate a conversation by sending a system message, setting the tone as a "knowledgeable assistant."
Finally, we pass the prompt to the model and return the generated response.

Step 2: Converting Text to Speech

To convert text to speech, we’ll use OpenAI’s TTS functionality. This TextToSpeechService class converts a given text to an audio file and plays it.

public class TextToSpeechService
{
    private readonly AudioClient _audioClient;

    public TextToSpeechService()
    {
        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
        _audioClient = new AudioClient("tts-1", apiKey);
    }

    public async Task ConvertTextToSpeechAsync(string text)
    {
        var speech = await _audioClient.GenerateSpeechAsync(text, GeneratedSpeechVoice.Onyx);
        using (var stream = File.OpenWrite("output.mp3"))
        {
            speech.ToStream().CopyTo(stream);
        }
        PlayAudio("output.mp3");
    }

    private void PlayAudio(string filePath)
    {
        using (var audioFile = new AudioFileReader(filePath))
        using (var outputDevice = new WaveOutEvent())
        {
            outputDevice.Init(audioFile);
            outputDevice.Play();
        }
    }
}

Key points:

ConvertTextToSpeechAsync accepts a text string, converts it into speech, and saves it as an MP3 file.
The PlayAudio method leverages NAudio for playback. It reads the MP3 file and plays it back on your system.

Step 3: Transcribing Audio to Text

The following SpeechToTextService class uses OpenAI’s Whisper model to transcribe audio files into text. This can be incredibly useful for processing voice input.

public class SpeechToTextService
{
    private readonly AudioClient _audioClient;

    public SpeechToTextService()
    {
        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
        _audioClient = new AudioClient("whisper-1", apiKey);
    }

    public async Task<string> TranscribeAudioAsync(string audioFilePath)
    {
        var transcription = await _audioClient.TranscribeAudioAsync(audioFilePath);
        return transcription.Text;
    }
}

This class:

Accepts an audio file path and transcribes the audio content into text.
The transcription result is returned as a plain text string.

Step 4: Recording Audio with NAudio

For applications that need to capture audio from the user, such as for speech-to-text input, you can use the NAudio library to record audio and save it as a .wav file. This is especially useful for Windows-based applications, where NAudio provides a straightforward API for handling audio input.

The StartRecordingAsync method below demonstrates how to record audio from the default microphone, saving it to a specified output file path.

public async Task StartRecordingAsync(string outputFilePath, CancellationToken cancellationToken)
{
    var waveFormat = new WaveFormat(44100, 16, 1); // 44.1 kHz, 16-bit, mono
    using (var waveIn = new WaveInEvent { WaveFormat = waveFormat })
    using (var writer = new WaveFileWriter(outputFilePath, waveFormat))
    {
        waveIn.DataAvailable += (sender, e) =>
        {
            writer.Write(e.Buffer, 0, e.BytesRecorded);
        };

        waveIn.StartRecording();

        try
        {
            await Task.Delay(Timeout.Infinite, cancellationToken); // Keeps recording until cancellation
        }
        catch (TaskCanceledException)
        {
            waveIn.StopRecording();
        }
    }
}

In this code:

Initialize Audio Format: We set up the audio format to 44.1 kHz, 16-bit, mono. These settings provide good quality for most voice recordings.
Create Audio Input and Writer: We use WaveInEvent for capturing audio from the default microphone and WaveFileWriter to write the audio data to a file.
Handle Data Available Event: As audio data becomes available (captured in chunks), it is written to the file through the writer.
Start and Stop Recording: Recording starts with StartRecording() and will continue until the provided CancellationToken is canceled, at which point StopRecording() is called to end the recording.

Usage Example

To start recording audio, you can call this method and provide a file path and cancellation token:

var recordingService = new AudioRecordingService();
var cancellationTokenSource = new CancellationTokenSource();

Console.WriteLine("Recording audio. Press any key to stop...");

_ = recordingService.StartRecordingAsync("recording.wav", cancellationTokenSource.Token);

// Wait for a key press to stop recording
Console.ReadKey();
cancellationTokenSource.Cancel();

This example will begin recording audio and save it to recording.wav until a key is pressed, triggering the cancellation of the recording.

With the addition of audio recording using NAudio, you now have a full toolkit for handling text generation, text-to-speech, speech-to-text, and audio recording within your .NET application. This setup provides a complete pipeline for interactive and conversational applications in .NET, enabling voice-based input, audio output, and seamless integration with OpenAI’s powerful language models.

Putting It All Together

With these services implemented, you have the foundation for a fully interactive .NET application that can generate text, convert text to speech, transcribe spoken input, and record audio. Here’s an example of how to use all four services in a cohesive application.

var openAiService = new OpenAiService();
var ttsService = new TextToSpeechService();
var sttService = new SpeechToTextService();
var recordingService = new AudioRecordingService();
var cancellationTokenSource = new CancellationTokenSource();

// Step 1: Generate a Text Response
string prompt = "Tell me something interesting about AI.";
string generatedText = await openAiService.GenerateResponseAsync(prompt);
Console.WriteLine("Generated Text: " + generatedText);

// Step 2: Convert Generated Text to Speech
await ttsService.ConvertTextToSpeechAsync(generatedText);

// Step 3: Record Audio Input
Console.WriteLine("Recording audio input. Press any key to stop recording...");
_ = recordingService.StartRecordingAsync("user_recording.wav", cancellationTokenSource.Token);
Console.ReadKey();
cancellationTokenSource.Cancel();

// Step 4: Transcribe Recorded Audio
string transcribedText = await sttService.TranscribeAudioAsync("user_recording.wav");
Console.WriteLine("Transcribed Text: " + transcribedText);

Conclusion

Using OpenAI’s .NET SDK alongside NAudio, you can bring powerful AI capabilities into your .NET applications. This integration covers:

Text Generation: Generate contextually relevant responses.
Text-to-Speech: Convert generated text to audio for a more interactive experience.
Speech-to-Text: Capture and transcribe user input.
Audio Recording: Enable seamless audio capture for user interactions.

This setup provides a complete, interactive pipeline that can power chatbots, virtual assistants, or any voice-enabled application. By following this guide, you’ll have a solid foundation for enhancing your .NET applications with AI-powered, voice-driven features.

Before You Go...

Did this guide help you level up your .NET skills with OpenAI integration? If so, let’s spread the knowledge! Give it a like, share with fellow devs, or drop a comment below. Every interaction helps boost this content, bringing these tips to more developers. And hey—if it didn’t deliver, no hard feelings; your silence speaks louder than clicks! 😉

Deesix: A Journey from MUDs to Modern AI-Powered RPGs

PeterMilovcik — Wed, 31 Jul 2024 11:33:14 +0000

A Nostalgic Journey

Back in the day, I spent countless hours exploring the immersive worlds of MUDs, those classic text-based games that brought fantasy adventures to life with just words on a screen. There was something magical about using our imagination to fill in the gaps, picturing vast dungeons, mythical creatures, and epic battles. It was a time of pure creativity and wonder, where every command could lead to a new discovery or challenge. Those games weren't just pastimes; they were gateways to other worlds, and I cherished every moment spent in them.

Now, as I look back, I find myself wanting to recreate that magic with a modern twist.

The Evolution of Technology and Gaming

With the rise of Generative AI, we've seen a huge leap in what technology can do. These advanced AI models can now create incredibly detailed descriptions, making it easier than ever to bring game worlds to life. Imagine walking into a room and instantly getting a vivid picture of its atmosphere, or encountering a character with a rich backstory—all generated on the fly. This technology has made it possible to craft immersive experiences that were once only possible in our imaginations.

For game developers, this means less time spent on manual content creation and more time focusing on making the game fun and engaging. It's a game-changer, opening up new possibilities for storytelling and player interaction.

Introducing Deesix: A Modern Text-Based RPG

Deesix is a modern take on the classic text-based RPGs that we all loved, blending old-school charm with new technology. Inspired by the traditional fantasy elements of games like Dungeons & Dragons, Deesix brings a unique twist with the help of Generative AI.

One of the standout features is the Game Master AI, which acts like a narrator and guide. It creates the game's world, describes locations, and offers a variety of actions for players to choose from. This AI isn't just static; it adapts to your choices, making the game feel alive and interactive.

Another cool aspect is the procedural generation. Every time you play, the world is freshly generated, so no two adventures are the same. This keeps things exciting and unpredictable, offering endless exploration possibilities. And for those who love a bit of randomness, the game mechanics revolve around using D6 dice, just like in tabletop RPGs. This simple yet engaging system adds an extra layer of fun and strategy to the gameplay.

The Development Journey: Challenges and Milestones

Creating Deesix is set to be an exciting adventure full of ups and downs. It will start with a simple idea: to bring the magic of old-school text-based RPGs into the modern era. I aim to capture that nostalgic feel while adding something fresh and new with the help of AI.

Of course, like any project, there will likely be challenges along the way. Balancing the AI's ability to generate engaging content with the player's freedom of choice could be a big one. I might also face technical hurdles, like optimizing the game for different platforms and ensuring the AI's responses are quick and relevant. But each challenge will be a learning experience, pushing me to find creative solutions and improve the game.

Despite these potential obstacles, I'm hopeful for great successes. Seeing the Game Master AI come to life and create dynamic, immersive worlds will be incredibly rewarding. Each milestone, from the first playable prototype to the refined gameplay mechanics, will bring me closer to making Deesix a reality. And I'm excited to share these experiences, both the successes and struggles, as I move forward with the game's development.

Future Updates and Community Engagement

As I continue developing Deesix, I'm eager to share my journey with you. This blog post is just the beginning. I'll be posting regular updates, detailing everything from our development milestones to the challenges I face. Whether it's a new feature I'm excited about or a problem I'm tackling, I want to keep you in the loop.

I also invite you to join the conversation and be a part of this journey. You can follow the #Deesix tag for updates or follow me directly for all my future posts. Your feedback and support will be invaluable as I bring this game to life. Let's explore this adventure together!

Conclusion: An Invitation to Join the Journey

I'm thrilled to embark on this journey of creating Deesix and bringing a fresh take on text-based RPGs to life. This project is more than just a game; it's a tribute to the nostalgic days of MUDs and a step into the future with Generative AI. I can't wait to share more about the development process, the ups and downs, and everything in between.

It's important to note that Deesix is just a side project of mine. While I'm passionate about it, I won't be able to work on it full-time. So, please don't expect miracles overnight. Progress might be steady but slow. However, your interest and support mean the world to me, and I'm excited to share each step of the journey with you. Together, let's create something amazing! Follow the #Deesix tag or my profile for the latest updates, insights, and stories from behind the scenes.

Image by Alejandro Burdisio/Burda

How to start with InfluxDB OSS v2 and C# Client Library for Windows and Docker

PeterMilovcik — Wed, 10 Apr 2024 09:36:59 +0000

What is InfluxDB OSS v2?

InfluxDB OSS (Open Source Software) v2 is the latest version of the InfluxDB time series database platform. It is designed to handle high write and query loads, making it a suitable tool for storing and analyzing large amounts of time-stamped data. This version combines capabilities from the previous versions of InfluxDB 1.x (like storage engine, query language) and other components like Chronograf (visualization) and Kapacitor (processing, alerting, and downsampling). It also introduces Flux, a new scripting and query language that supports analytics across measurements.

Step 1: Install Docker Desktop on Windows

Before you begin, you need Docker Desktop installed on your Windows machine. Docker Desktop provides an easy-to-use interface and the Docker CLI (Command Line Interface) necessary for running containerized applications like InfluxDB.

Download Docker Desktop: Go to the Docker Desktop: The #1 Containerization Tool for Developers | Docker and download the latest version of Docker Desktop for Windows.
Installation: Run the installer and follow the on-screen instructions. Make sure to enable the WSL 2 feature if prompted, as it's required for Docker Desktop to run efficiently on Windows.
Verification: After installation, open a terminal (you can use PowerShell or the Windows Command Prompt) and type docker --version to verify that Docker has been installed correctly. You should see the Docker version displayed.

Step 2: Pull and Run the InfluxDB Docker Image

First, ensure you have Docker Desktop installed. Then, use the terminal to pull the latest version of InfluxDB, version 2.7 as of today (2024-04-10). Verify the latest version on Docker Hub.

Pull the InfluxDB Image: Execute docker pull influxdb:2.7 in the terminal to download the InfluxDB 2.7 image.
Run the Container: Use the command below to start your InfluxDB container:

docker run --name influxdb2 -d -p 8086:8086 -v influxdb2-data:/var/lib/influxdb2 -v influxdb2-config:/etc/influxdb2 influxdb:2.7

--name influxdb2: Assigns the container a name (influxdb2) for easy reference.
-d: Runs the container in detached mode, meaning it runs in the background.
-p 8086:8086: Maps port 8086 inside the container to port 8086 on your host, making the InfluxDB UI accessible at http://localhost:8086.
-v: Creates volumes for persistent data storage and configuration settings, ensuring your data is saved outside the container.

This command sets up InfluxDB version 2.7 in a container, making it ready for configuration and use.

Step 3: Configure InfluxDB

After starting the container, you'll need to configure InfluxDB.

Access the InfluxDB UI: Open your web browser and go to http://localhost:8086. You should see the InfluxDB welcome screen.

Initial Setup: Follow the prompts to create an initial user, organization, and bucket. Remember the credentials you set here; you'll need them for accessing InfluxDB later.
Secure Your InfluxDB: It's crucial to secure your InfluxDB instance. Make sure to note down the generated token during setup, as it's needed for API authentication.

Step 4: Creating a Simple Console Application with .NET 8 Using the InfluxDB C# Client Library

Create a New Console Application: Open your terminal or command prompt, navigate to the desired directory, and run following command to create a new .NET 8 console application.

dotnet new console -n InfluxDB2Demo

Install the InfluxDB Client Library: Use the .NET CLI command to add the InfluxDB client package to your project.

cd InfluxDB2Demo
dotnet add package InfluxDB.Client

Open console application in your favorite IDE, e.g., Visual Studio Code:

code .

Open Program.cs file to continue.

Initialize the Client:

To initialize the InfluxDB client in a C# application:

Reference the InfluxDB Client Namespace: Add using InfluxDB.Client; at the top of your program file.
Create the Client Instance: Instantiate the InfluxDBClient by calling its constructor with two arguments: the URL to your InfluxDB instance and your InfluxDB token.
Write Data:
- By POCO: Define a class with your data schema, instantiate it, and write it using writeApi.WriteMeasurement().
Query Data: Write a Flux query string to retrieve data from your bucket and use influxDBClient.GetQueryApi().QueryAsync() to execute the query and process the results.

using InfluxDB.Client;
using InfluxDB.Client.Api.Domain;
using InfluxDB.Client.Core;

internal class Program
{
    private static async Task Main(string[] args)
    {
        var url = "http://localhost:8086";
        var token = "Your_InfluxDB_Token";
        using var client = new InfluxDBClient(url, token);

        // Write data
        using var writeApi = client.GetWriteApi();
        var temperature = new Temperature { Location = "south", Value = Random.Shared.Next(-30, 40), Time = DateTime.UtcNow };
        writeApi.WriteMeasurement(temperature, WritePrecision.Ns, "bucket_name", "org_id");

        // Query data
        var flux = "from(bucket:\"bucket_name\") |> range(start: 0)";
        var fluxTables = await client.GetQueryApi().QueryAsync(flux, "org_id");
        fluxTables.ForEach(fluxTable =>
        {
            var fluxRecords = fluxTable.Records;
            fluxRecords.ForEach(fluxRecord =>
            {
                Console.WriteLine($"{fluxRecord.GetTime()}: {fluxRecord.GetValue()}");
            });
        });
    }
}

[Measurement("temperature")]
class Temperature
{
    [Column("location", IsTag = true)] public string? Location { get; set; }
    [Column("value")] public double Value { get; set; }
    [Column(IsTimestamp = true)] public DateTime Time { get; set; }
}

NOTE: Ensure you replace "Your_InfluxDB_Token" with your actual InfluxDB API token created in Step 3, similarly also bucket_name and org_id.

This simplified guide helps you set up a basic application to interact with InfluxDB.
For detailed documentation and examples, refer to the influxdata/influxdb-client-csharp: InfluxDB 2.x C# Client (github.com).

You've taken a big step by learning how to set up and start using InfluxDB OSS v2 with Docker and C#. This guide is just the beginning. There's a lot more you can do:

Learn More About Flux: Get better at using Flux for more complex data tasks.
Learn More About Data Retention: Learn about data retention and how to keep your database running smoothly as it grows.
Learn More About Buckets in InfluxDB: Get better understanding of how and where time series data is stored.
Join the Community: There's a big community out there. Join forums, share ideas, and get help.

Remember, practice makes perfect. Keep exploring and experimenting with InfluxDB to get the most out of it. For more guides and support, check out the InfluxDB official page.

Understanding BehaviorSubject in Angular Through the Thermometer Analogy

PeterMilovcik — Thu, 28 Sep 2023 08:58:34 +0000

When learning Angular and delving into the reactive programming paradigm, it's easy to stumble upon terms that may seem intimidating—Observable, Subject, BehaviorSubject, and so on. Today, we're going to demystify one of these terms: BehaviorSubject.

Introduction
What is BehaviorSubject?
The Thermometer Analogy
Using next() Method
BehaviorSubject vs Observable
Conclusion

1. Introduction

Angular relies heavily on reactive programming patterns, particularly those provided by the RxJS library. Reactive programming is all about dealing with asynchronous operations and data streams. This is where BehaviorSubject comes in as a powerful construct for managing these streams.

2. What is BehaviorSubject?

A BehaviorSubject is a type of subject, a particular kind of observable in RxJS. What makes it unique is that it stores the "current" value. This means that when you subscribe to it, you immediately get the latest emitted value—or a default value if none has been emitted yet.

import { BehaviorSubject } from 'rxjs';

const temperature$ = new BehaviorSubject<number>(20);

In the code above, temperature$ is a BehaviorSubject that starts with an initial value of 20. The $ at the end is a naming convention often used for Observables.

3. The Thermometer Analogy

Think of BehaviorSubject as a digital thermometer in a room. Various departments in an organization—say, Maintenance, Operations, and HR—need to know the room's temperature.

Initialization

When you set up the thermometer, you determine that the initial temperature is 20°C. This initial value is crucial for any department that decides to monitor the temperature.

Subscriptions

Maintenance and Operations departments 'subscribe' to the thermometer. From that point on, they get updated readings whenever the temperature changes.

temperature$.subscribe((temp) => {
  console.log(`Maintenance department: Current temperature ${temp}°C`);
});

temperature$.subscribe((temp) => {
  console.log(`Operations department: Current temperature ${temp}°C`);
});

New Subscription

Now, HR also decides to subscribe. The moment they do, they receive the current temperature, not the initial one.

4. Using `next()` Method

To change the thermometer's reading, you use the next() method. This action updates the current value and informs all subscribers about this change.

temperature$.next(22);

This will log:

Maintenance department: Current temperature 22°C
Operations department: Current temperature 22°C

The next() function effectively pushes the new value into the BehaviorSubject, updating all active subscribers.

5. BehaviorSubject vs Observable

You might ask, "How is this different from an Observable?" The crucial difference lies in the initial value and the immediate availability of the current value. With a standard Observable, new subscribers would have to wait for a new value to be emitted. They don't get the latest value right when they subscribe, as with BehaviorSubject.

6. Conclusion

Understanding BehaviorSubject can significantly impact how you manage state and data flow in Angular applications. The ability to emit, listen, and react to new data points in different parts of your application is not just powerful; it also aligns closely with Angular's reactive ethos.

With this newfound knowledge, you're one step closer to mastering Angular's reactive landscape. Happy coding!

10 Psychological Archetypes of Test Automation Engineers: Which One Are You?

PeterMilovcik — Sat, 19 Aug 2023 13:58:54 +0000

In the vast universe of software development, test automation engineers play a pivotal role in ensuring software's reliability and robustness. Yet, beyond the technical aspects, there’s a fascinating human element at play. These engineers, driven by unique psychological traits, embody distinct archetypes that define their work approach. In diving deep into these archetypes, we might not only understand our colleagues better but also unearth our own latent traits.

1. The Perfectionist

For the Perfectionist, every script is a masterpiece. Their pursuit of flawlessness might sometimes be their Achilles' heel as they often risk getting entangled in the minutiae.

2. The Quick-Fixer

Ever seen tests get up and running in the blink of an eye? Thank the Quick-Fixer. But, like every rose has its thorn, this speed sometimes comes at the cost of sustainability.

3. The Strategist

This archetype sees beyond the immediate. They're the architects, ensuring the foundations are robust. Their test frameworks don’t just serve the present but are scalable visions for the future.

4. The Collaborator

The belief driving the Collaborator is simple: unity is strength. They know the magic that unfolds when minds come together, resulting in automation solutions that are greater than the sum of their parts.

5. The Innovator

In a rapidly evolving tech landscape, the Innovator is our beacon. With an insatiable appetite for the novel, they’re our bridge to the latest in tools and methodologies.

6. The Taskmaster

Every team needs its pulse. And the Taskmaster is just that. Their rigorous schedules and checklists ensure that the ship not only sails but also stays its course.

7. The Challenger

Status quo? Not for the Challenger. With an instinct to question, they ensure that we don't just do things right, but we also do the right things.

8. The Learner

In an age of information, the Learner thrives. Their continuous journey of upskilling is a testament to their belief in evolution – both personal and professional.

9. The Mentor

The cycle of knowledge is complete when it’s passed on. The Mentor ensures this cycle never breaks. Their wisdom is not just their own but a lantern for others.

10. The Achiever

For some, the journey is the reward. For the Achiever, it's the milestones. Every test coverage percentage and implemented test case is a feather in their cap.

In recognizing these archetypes, we don’t box individuals but rather celebrate the diversity of approaches. After all, it's this very diversity that enriches our teams and our solutions. So, the next time you’re in a meeting or a code review, take a moment. Look around. Which archetype do you see? More importantly, which one do you resonate with?

Join the Conversation

So, which archetype resonates with you? Or do you see a bit of yourself in multiple roles? Discovering our archetype isn't just about introspection; it's a doorway to improved collaboration and team synergy. Share this post with your colleagues and ignite a fun, introspective discussion! Who knows, understanding these profiles might just be the key to unlocking your team's next breakthrough. After all, in the intricate dance of software development, every step, every trait, and every individual matters. Dive deep, engage, and let's keep the conversation alive!

Modern Note-Taking: How Obsidian Stands Out in 2023

PeterMilovcik — Sat, 19 Aug 2023 12:48:01 +0000

In the vast galaxy of digital note-taking, stars emerge, flicker, and fade. Yet, as we barrel into 2023, one star blazes more brilliantly than the rest: Obsidian. As we wade through the deluge of our digital thoughts, a sanctuary like Obsidian becomes not just desirable, but downright essential.

The Allure of the Local-First Paradigm

In an age where cloud-based everything seems the norm, Obsidian's audacious move towards a local-first approach is both a breath of fresh air and a grounding reminder. There’s an oddly satisfying nostalgia in knowing your thoughts are safely stored on your own machine, reminiscent of scribbling in a physical journal under the cover of night.

Interlinking Thoughts: A Web of Brilliance

Remember those detective shows with walls covered in pictures, connected by strings in a maze of theories and suspects? That’s Obsidian’s backlinking and graph view for you. But instead of solving crimes, you’re untangling the intricate mysteries of your own mind, making connections you might never have otherwise perceived.

Customization: A Playground for the Inquisitive

Why accept a one-size-fits-all when you can tailor to perfection? Obsidian isn’t just a tool; it's a canvas. Whether you're a minimalist seeking an uncluttered space or a maximalist hungering for intricate toolsets, Obsidian bends to your will.

Knowledge, Not Notes

While most apps let you take notes, Obsidian lets you craft a knowledge base. It’s a subtle distinction, but one that shifts the focus from mere information recording to genuine understanding. It nudges you gently towards epiphanies and a-ha moments, those delightful instances when the fog lifts and clarity reigns.

The Timelessness of Markdown

And, of course, the beating heart of Obsidian - markdown. In 2023, as more apps become bloated with features, the purity and simplicity of markdown stand unyielding. It's a nod to the digital romantics among us, who believe that words, in their most unadorned form, are magic enough.

The Quiet Revolution of Obsidian

So, here we stand, on the precipice of an ever-evolving digital age, our thoughts scattered like leaves in the wind. But with Obsidian, there's a sense of grounding, a sense of coming home. In the crowded arena of note-taking apps, Obsidian doesn’t just stand out; it gleams, a beacon for those seeking a deeper, more profound relationship with their thoughts.

Let's embrace this tool not just for its features, but for the introspection and clarity it beckons us towards. After all, in the cacophony of modern life, a sanctuary for our thoughts is the most profound rebellion.