Agentic AI with .NET & GCP

Enable Vertex AI and Generative Language APIs in a GCP project and configure billing quotas

Set up service accounts, IAM roles, and Application Default Credentials for AI workloads

Authenticate to Gemini and Vertex AI from a .NET application using Google.Apis.Auth

Send a basic chat completion request to Gemini via REST from C# using HttpClient

Use the Google.Cloud.AIPlatform.V1 SDK to call Gemini models from .NET

Stream Gemini responses token-by-token in a .NET console or web app

Handle common API errors and exceptions from the Vertex AI SDK, such as rate limits or content safety blocks

Monitor Vertex AI usage, latency, and cost in the GCP console

Structure a prompt with system, user, and assistant roles for chat models

Apply zero-shot prompting to instruct the model on a novel task

Apply few-shot prompting to provide in-context examples for improved accuracy

Apply chain-of-thought prompting to encourage step-by-step reasoning

Use Gemini's structured output / response schema feature from .NET to return reliable JSON

Write defensive prompts that resist common prompt injection attacks

Manage and version prompts as code artifacts with automated tests for output structure and quality

Estimate and optimize prompt token cost for high-volume scenarios

Explain Semantic Kernel's architecture: Kernel, connectors, plugins, and services

Install Semantic Kernel NuGet packages and configure a Kernel with the Google AI connector

Invoke a Gemini chat completion through Semantic Kernel's IChatCompletionService

Create and invoke a prompt-based semantic function using the default prompt template engine

Use the Handlebars prompt template engine for more advanced templated prompts

Create a native C# function plugin and register it with the Kernel

Configure logging, telemetry, and dependency injection for Semantic Kernel in ASP.NET Core

Handle errors, retries, and rate limits when calling Gemini through Semantic Kernel

Explain how LLM function/tool calling works at the API level with Gemini

Define a tool schema in C# using Semantic Kernel's KernelFunction attributes

Enable automatic function calling in Semantic Kernel with FunctionChoiceBehavior

Build a logistics plugin exposing functions like GetShipmentStatus and AssignDriver

Wrap an external REST API (e.g., a tracking service) as a Semantic Kernel plugin

Handle multi-step tool-calling loops and inspect intermediate function calls

Validate and sanitize LLM-generated arguments before invoking real-world tools

Design idempotent and safe tools for write operations in production

Explain the RAG pattern and when it is preferable to fine-tuning

Chunk documents effectively for embedding (size, overlap, semantic boundaries)

Generate embeddings for document chunks using the Vertex AI 'text-embedding-gecko' model from .NET

Provision a Vertex AI Vector Search index via the Google Cloud SDK from .NET

Upsert document chunk embeddings into the Vertex AI Vector Search index

Query the Vertex AI Vector Search index from .NET to retrieve relevant chunks

Build a RAG chain in Semantic Kernel that grounds Gemini answers in retrieved chunks with citations

Evaluate RAG quality with context precision, context recall, and answer faithfulness metrics

Contrast the ReAct (Reason-Act) and Plan-and-Execute agent paradigms

Describe the role of self-critique in advanced agent patterns like Reflexion

Implement a ReAct-style reasoning loop in C# using Semantic Kernel

Use Semantic Kernel's Function Calling Stepwise Planner to plan multi-step tasks

Design an agent's system prompt, persona, and operating constraints

Implement a reflection / self-critique step to improve agent output quality

Manage an agent's transient scratchpad and intermediate reasoning traces within a single reasoning loop

Set step limits, timeouts, and budget guards to prevent runaway agent loops

Differentiate short-term (conversation) memory from long-term (persistent) memory

Explain why long conversations require summarization to stay within the context window

Use Semantic Kernel's IChatHistoryReducer to keep chat history within token limits

Define a C# data model for persisting agent conversation history and scratchpad state

Implement saving and loading of agent state using the Google Cloud Firestore SDK from .NET

Implement semantic long-term memory backed by Vertex AI Vector Search

Implement memory expiration (TTL) and eviction (LRU) policies for agent memory

Design a scalable and cost-effective state persistence strategy using Google Cloud Firestore

Explain when multi-agent designs outperform a single agent with many tools

Compare orchestration patterns: supervisor, sequential, group chat, and hand-off

Define a ChatCompletionAgent using Semantic Kernel's Agent Framework

Define specialist agents for logistics tasks such as shipment tracking and exception handling

Implement a supervisor agent that routes user requests to the appropriate specialist

Implement a multi-agent conversation using the standard AgentGroupChat

Customize an AgentGroupChat with custom termination and speaker selection strategies

Coordinate hand-offs between agents using direct message passing and shared state objects

Apply Vertex AI safety filters and configure harm-category thresholds

Implement input guardrails to detect and mitigate common prompt injection techniques

Implement a PII redaction service and apply it as a guardrail for agent inputs, outputs, and persisted memory

Configure the OpenTelemetry SDK in a .NET agent and instrument tracing for agent and tool calls

Record custom agent metrics (token usage, tool errors) and structured logs with OpenTelemetry, exported to Google Cloud Trace, Logging, and Monitoring

Use exported telemetry to debug and trace multi-agent conversations end-to-end

Define a golden dataset and key quality metrics, and implement an offline evaluation runner in C#

Use LLM-as-a-judge scoring to evaluate agent responses on correctness and helpfulness

Expose the agent via an authenticated REST API built with ASP.NET Core

Implement streaming responses (Server-Sent Events) from the agent endpoint to clients

Containerize a .NET agent service with a production-ready Dockerfile

Manage secrets (API keys, connection strings) with Google Secret Manager from .NET

Deploy the agent as a Cloud Run service with appropriate concurrency and scaling settings

Set up CI/CD with Cloud Build to deploy agent updates automatically

Configure a canary deployment in Cloud Run by splitting traffic between revisions, with a rollback plan

Implement prompt caching and semantic caching to reduce per-request cost

Define requirements, scope, and success metrics for a logistics operations agent

Design the agent's tool surface for both read-only queries and safe state-changing operations across shipments, routes, drivers, and exceptions

Build a data pipeline to chunk, embed, and ingest logistics SOPs and policies into Vertex AI Vector Search

Integrate the RAG-grounded knowledge layer into the agent's reasoning process

Implement specialist agents for dispatch, tracking, and customer communications using the Agent Framework

Implement a supervisor (or group chat) to orchestrate the dispatch, tracking, and customer-comms specialists

Add guardrails, OpenTelemetry observability, and an offline evaluation harness to the capstone agent

Deploy the capstone agent to Cloud Run via a Cloud Build CI/CD pipeline and produce architecture documentation