DEV Community: Gunpal Jain

Build Claude Desktop Extensions in Minutes with QuickMCP.NET

Gunpal Jain — Sat, 22 Nov 2025 01:12:13 +0000

Hey developers!

Remember the last time you tried to integrate a REST API with Claude Desktop? Yeah, me too. It involved reading through MCP docs, writing YAML configs, figuring out authentication, and probably a few frustrated sighs.

What if I told you there's a better way? A way that involves one command and lets AI do the heavy lifting?

Let me introduce you to QuickMCP.NET - specifically its brand new Claude Desktop Extension Builder. Trust me, this is going to blow your mind.

The Problem We've All Had

You've got a REST API. Maybe it's your company's internal API, maybe it's Stripe, GitHub, or that quirky microservice Bob built. You want Claude to interact with it.

So you dive into the Model Context Protocol docs and realize you need to:

Write an MCP server configuration
Configure authentication (API keys, OAuth, whatever)
Create a manifest file with proper metadata
Write user-friendly descriptions for every config field
Package it all into a .mcpb file
Hope it actually works

By the time you're done, you've spent 3 hours on what should've been a 5-minute task.

Enter QuickMCP.NET: Your New Best Friend

QuickMCP.NET is a .NET toolkit that generates MCP servers from OpenAPI/Swagger specs. But the real magic is in the new Claude Extension Builder feature.

Here's what it does:

AI-powered metadata generation using Google Gemini
Automatic auth detection from your config
Smart placeholder parsing for environment variables
One-command packaging to .mcpb files
Auto-generated README with install instructions

Let me show you how ridiculously easy this is.

The "Holy Crap That's Easy" Example

Let's say you want to build a Stripe API extension. First, create your config file with QuickMCP CLI:

# Build a config file with authentication placeholders
quickmcp build config \
  --spec-url https://api.stripe.com/v1/openapi.yaml \
  --server-name "Stripe API" \
  --auth bearer

QuickMCP will guide you through authentication setup, and you'll use placeholders for secrets like {{STRIPE_API_KEY}}. You'll end up with a config file like this:

{
  "type": "openapi",
  "serverName": "Stripe API",
  "apiSpecUrl": "https://api.stripe.com/v1/openapi.yaml",
  "apiBaseUrl": "https://api.stripe.com",
  "authentication": {
    "type": "bearer",
    "settings": {
      "token": "{{STRIPE_API_KEY}}"
    }
  }
}

Now watch this - turn it into a Claude Desktop extension:

quickmcp build ce -c stripe_config.json -m -k YOUR_GEMINI_KEY

That's it. ONE command.

Here's what just happened:

Parsed your config
Found the {{STRIPE_API_KEY}} placeholder
Asked Gemini 2.5 Flash: "Hey, what should users know about this?"
Gemini responds: "This is a Stripe API key, format is sk_..., it's sensitive, here's a helpful description..."
Generated a beautiful manifest with user-friendly forms
Created a README with installation steps
Packaged everything into stripe.mcpb

The result? A production-ready Claude Desktop extension that users can install with a few clicks.

The AI Magic Under The Hood

This is where it gets really cool. When you enable AI metadata (-m flag), QuickMCP sends your config to Gemini and asks it to analyze everything:

For your auth variables, it generates:

User-friendly titles ("API Key" instead of "API_KEY")
Helpful descriptions ("Enter your API key from the Stripe dashboard...")
Format hints ("sk_live_..." or "Bearer ...")
Sensitivity markers (automatically marks secrets)

For your extension, it creates:

Professional display name
Clear, concise description
Relevant keywords for search
Author info (extracted from API metadata)

Here's a real example. Without AI:

{
  "title": "CLIENT_SECRET",
  "description": "Enter your CLIENT_SECRET"
}

Meh.

With AI:

{
  "title": "OAuth Client Secret",
  "description": "Your OAuth 2.0 client secret from the developer console. This is used alongside your client ID to authenticate token requests. Keep this confidential!",
  "format_hint": "Usually a 32-character hex string",
  "sensitive": true
}

Now we're talking!

Two Ways to Build: Maximum Flexibility

Option 1: Two-Step Process (Recommended)

Step 1: Build your config file first (gives you more control):

# Create config with authentication
quickmcp build config \
  --spec-url https://api.github.com/openapi.yaml \
  --server-name "GitHub API" \
  --auth bearer

# This creates a config file with {{GITHUB_TOKEN}} placeholder
# Edit it if needed, then build the extension

Step 2: Build the Claude extension:

quickmcp build ce \
  -c github_config.json \
  -m \
  --author-name "Your Company"

Option 2: All-in-One

Create config and extension in a single command:

quickmcp build ce \
  --spec-url https://api.github.com/openapi.yaml \
  --server-name "GitHub API" \
  --auth bearer \
  -m \
  --author-name "Your Company"

Both workflows give you the same beautiful result: a ready-to-install .mcpb package.

Pro tip: The two-step process is recommended because it lets you review and customize the config file before building the extension. You can add custom authentication settings, filter API paths, or tweak the configuration.

Real-World Example: GitHub Integration

Let's build a GitHub API extension together from scratch.

Step 1: Create the config file:

quickmcp build config \
  --spec-url https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --server-name "GitHub API" \
  --auth bearer

During setup, you'll be prompted to configure authentication. Use {{GITHUB_TOKEN}} as the token placeholder. This creates a config file:

{
  "type": "openapi",
  "serverName": "GitHub API",
  "apiSpecUrl": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json",
  "apiBaseUrl": "https://api.github.com",
  "authentication": {
    "type": "bearer",
    "settings": {
      "token": "{{GITHUB_TOKEN}}"
    }
  }
}

Step 2: Build the Claude extension:

quickmcp build ce \
  -c github_config.json \
  -m \
  --author-name "GitHub" \
  --author-url "https://github.com"

Output:

✓ Using existing config file: github_config.json
✓ Analyzing configuration and generating metadata...
✓ Using AI-generated display name: GitHub API Integration
✓ Using AI-generated description: Access GitHub's REST API to manage repositories, issues, pull requests, and more
✓ Using AI-generated keywords: github, api, git, repositories, ci-cd
✓ Generated comprehensive metadata successfully!

For environment variable: GITHUB_TOKEN
  • Title: GitHub Personal Access Token
  • Description: A personal access token from your GitHub account settings with appropriate scopes...
  • Format: ghp_...
  • Sensitive: Yes

✓ Generating manifest.json...
✓ Generating README.md...
✓ Creating .mcpb package...
✓ Package created: github.mcpb

Claude Desktop extension successfully built!

You now have a github.mcpb file ready to distribute!

What's Inside The Package?

When you build an extension, you get:

output-directory/
├── manifest.json          # Extension metadata
├── github_config.json     # MCP server config
├── openapi.json          # API specification
├── README.md             # Installation guide
└── github.mcpb           # The installable package

The manifest.json is where the magic happens:

{
  "manifest_version": "0.3",
  "name": "github",
  "display_name": "GitHub API Integration",
  "version": "1.0.0",
  "description": "Access GitHub's REST API...",
  "server": {
    "type": "binary",
    "entry_point": "quickmcp",
    "mcp_config": {
      "command": "quickmcp",
      "args": ["serve", "--config-path", "${__dirname}/github_config.json"],
      "env": {
        "GITHUB_TOKEN": "${user_config.githubtoken}"
      }
    }
  },
  "user_config": {
    "githubtoken": {
      "type": "string",
      "title": "GitHub Personal Access Token",
      "description": "A personal access token from your GitHub account settings...",
      "required": true
    }
  }
}

See that user_config section? That's what creates the nice UI in Claude Desktop for users to enter their credentials. No more config file editing!

Installing Your Extension

Your users get a super smooth experience:

Step 1: Install QuickMCP CLI (one-time setup)

dotnet tool install -g quickmcp.cli

Step 2: Install the extension in Claude Desktop

Open Claude Desktop
Settings → Extensions
"Install Extension..."
Select the .mcpb file
Enter their credentials in the nice form
Restart Claude

Step 3: Start using it!

Claude can now interact with your API. No more copy-pasting curl commands!

The Developer Experience is Fire

Here's what I love most about this workflow:

1. It Just Works™

No YAML indentation hell. No "why isn't this working?" debugging sessions. The CLI validates everything and gives you clear error messages.

2. AI Does The Boring Stuff

Writing descriptions for 15 different OAuth parameters? Pass. Let Gemini handle it. You focus on the fun stuff.

3. Type Safety Built-In

It's .NET, so you get all the type safety, intellisense, and tooling you love. The generated MCP servers are robust and production-ready.

4. Instant Feedback

quickmcp serve -c config.json

Test your server instantly. No deploy, no container builds. Just run it.

5. Cross-Platform

Works on Windows, macOS, and Linux. Your extensions work everywhere Claude Desktop works.

Advanced: Batch Build Multiple Extensions

Got 10 APIs to integrate? No problem:

# Set your Gemini key once
export GOOGLE_API_KEY=your_key

# Build them all
for config in configs/*.json; do
  quickmcp build ce -c "$config" -m
done

Boom. 10 production-ready extensions in seconds.

Authentication: We Support It All

QuickMCP handles pretty much every auth method:

API Keys (header, query param)
Bearer Tokens
Basic Auth
OAuth 2.0 (all grant types!)
Custom Headers
Custom Authenticators (roll your own!)

And with the AI metadata generator, users get clear instructions for every auth type.

Tips & Tricks

Use Environment Variables Everywhere

Always use placeholders for secrets:

{
  "apiKey": "{{API_KEY}}"        // Good
  "apiKey": "sk_live_real_key"   // Bad
}

Let AI Do The Work

Compare these:

Without AI (--author-name "Required" only):

Minimal metadata
Generic descriptions
More manual work

With AI (-m flag):

Rich, helpful metadata
Context-aware descriptions
Nearly zero manual work

The choice is obvious!

Test Before Distributing

# Build
quickmcp build ce -c config.json -m

# Extract and test
unzip your_api.mcpb -d test/
quickmcp serve -c test/your_api_config.json

# Make requests to test it

Version Your Extensions

quickmcp build ce \
  -c config.json \
  --version "2.0.0" \
  -m

Semantic versioning keeps your users happy!

The Full Command Reference

Here's the complete syntax:

quickmcp build ce \
  -c <config-path>              # Or --spec-url for new configs
  -m                            # Enable AI metadata
  -k <gemini-api-key>           # Or use GOOGLE_API_KEY env var
  --author-name "Your Name"     # Required unless using -m
  --display-name "My Extension" # Optional, AI can generate
  --description "What it does"  # Optional, AI can generate
  --version "1.0.0"             # Optional, defaults to 1.0.0
  --keywords "api,integration"  # Optional, AI can generate
  --author-url "https://..."    # Optional
  --homepage "https://..."      # Optional
  --documentation "https://..." # Optional
  --license "MIT"               # Optional, defaults to MIT
  -o ./output                   # Optional output directory
  --skip-readme                 # Skip README generation

Aliases: These all work the same:

quickmcp build ce
quickmcp build claude-extension
quickmcp build claude

What Else Can QuickMCP Do?

The extension builder is the newest feature, but QuickMCP has been around for a bit with some other cool features:

Build Config Files First

Before building extensions, you can create and test your MCP server configuration:

# Build a config with interactive prompts
quickmcp build config \
  --spec-url https://petstore.swagger.io/v2/swagger.json \
  --server-name "Petstore" \
  --auth apiKey

# Test it immediately
quickmcp serve --config-path petstore_config.json

Boom. MCP server running from your config. Test it, tweak it, then build the extension.

.NET Library Integration

var serverInfo = await McpServerInfoBuilder.ForOpenApi()
    .FromUrl("https://api.example.com/openapi.json")
    .WithBaseUrl("https://api.example.com")
    .AddAuthentication(new ApiKeyAuthenticator("key", "X-API-Key"))
    .BuildAsync();

// Integrate with official MCP C# SDK
services
    .AddMcpServer()
    .WithQuickMCP(serverInfo)
    .WithStdioServerTransport();

Type-safe, async, and production-ready.

Server Registry

# Save a server config
quickmcp add server config.json -n MyAPI

# List your servers
quickmcp list server

# Serve by name
quickmcp serve -i MyAPI

No more hunting for config files!

Common Questions

Q: Do I need to know .NET to use this?
A: Nope! The CLI is standalone. Just install and run.

Q: Does it cost money?
A: QuickMCP is free and MIT licensed. You only pay for Gemini API calls (fractions of a penny per build).

Q: Can I use it without AI?
A: Yep! Just skip the -m flag and provide metadata manually.

Q: What if my API doesn't have an OpenAPI spec?
A: You can write a config manually, or use the build spec command to generate one from documentation URLs!

Q: Does it work with private APIs?
A: Absolutely! Point it at your internal OpenAPI spec or discovery doc.

Q: Can I customize the generated files?
A: Sure! They're all JSON/Markdown. Edit after generation if needed.

Get Started Now!

Install QuickMCP CLI

dotnet tool install -g quickmcp.cli

Get a Gemini API Key

Visit https://aistudio.google.com/app/apikey
Create a new API key (free tier available!)
Set it: export GOOGLE_API_KEY=your_key

Build Your First Extension

Option A: Two-step (recommended for learning)

# Step 1: Create config
quickmcp build config \
  --spec-url https://petstore.swagger.io/v2/swagger.json \
  --server-name "Petstore API" \
  --auth apiKey

# Review the generated config file, then...

# Step 2: Build extension
quickmcp build ce \
  -c petstore_config.json \
  -m \
  --author-name "Swagger"

Option B: All-in-one (faster)

quickmcp build ce \
  --spec-url https://petstore.swagger.io/v2/swagger.json \
  --server-name "Petstore API" \
  --auth apiKey \
  -m \
  --author-name "Swagger"

# Install petstore.mcpb in Claude Desktop
# Profit!

Join The Community

This is still pretty new, and we'd love your feedback!

Star the repo: github.com/gunpal5/QuickMCP
Report issues: Use GitHub Issues
Feature ideas: Open a discussion
Read the docs: Check out the wiki
Try it out: Build something cool and share!

Wrapping Up

Look, I get it. You've got APIs to integrate, features to ship, and limited time. QuickMCP's Claude Extension Builder gives you back that time.

One command. AI-powered metadata. Production-ready extensions. What are you waiting for?

Go build something awesome!

Try it now:

dotnet tool install -g quickmcp.cli
quickmcp build ce --help

Links:

Have you built a Claude Desktop extension? What APIs are you integrating? Drop a comment below!

Supercharge Google Gemini with MCP: Connect Any Tool to Your AI!

Gunpal Jain — Sat, 08 Nov 2025 10:01:37 +0000

Hey everyone!

If you've been working with AI and thought, "I wish my AI could access anything files, databases, APIs, custom tools..." you're in luck! Today, I'm excited to show you how to connect Google Gemini to the Model Context Protocol (MCP), unlocking a universe of external tools and services.

By the end of this article, you'll be able to connect Gemini to file systems, GitHub, databases, Slack, and practically any service that supports MCP. Let's dive in!

What is MCP?

Think of MCP as a universal adapter for AI models. Just like USB-C works with any compatible device, MCP provides a standardized way for AI models to connect to external tools and services.

Instead of building custom integrations for each service, MCP lets you:

Access file systems - Read, write, and search files
Connect to GitHub - Create issues, search repos, manage PRs
Query databases - Run SQL queries, fetch data
Integrate with Slack - Send messages, read channels
Use any MCP server - Hundreds of community servers available!

The best part? All with the same simple API. No need to learn different SDKs for each service!

Prerequisites

Before we begin, make sure you have:

.NET 8.0 or later installed
Google API Key from Google AI Studio
Node.js (for running MCP servers)
The Google_GenerativeAI.Tools NuGet package:

dotnet add package Google_GenerativeAI.Tools

Part 1: Understanding MCP Integration

The Three Transport Types

MCP supports three ways to connect to servers:

1. Stdio (Subprocess)

Launch an MCP server as a child process. Perfect for local tools!

var transport = McpTransportFactory.CreateStdioTransport(
    name: "filesystem",
    command: "npx",
    arguments: new[] { "-y", "@modelcontextprotocol/server-filesystem", "/path/to/files" }
);

When to use: Local file operations, running scripts, development

2. HTTP/SSE (Remote)

Connect to a remote MCP server over HTTP with Server-Sent Events.

var transport = McpTransportFactory.CreateHttpTransport(
    baseUrl: "https://api.example.com/mcp"
);

When to use: Cloud services, shared tools, production deployments

3. HTTP with Authentication

Same as HTTP but with authentication headers.

var transport = McpTransportFactory.CreateHttpTransportWithAuth(
    baseUrl: "https://api.example.com/mcp",
    authToken: "your-secret-token"
);

When to use: Protected APIs, enterprise services

Part 2: Building a Real Application

Let's build something practical: A Gemini-powered file assistant that can read, search, and summarize files on your computer!

Step 1: Create the Project

dotnet new console -n GeminiFileAssistant
cd GeminiFileAssistant
dotnet add package Google_GenerativeAI.Tools

Step 2: Connect to the Filesystem MCP Server

Create a new file Program.cs:

using GenerativeAI;
using GenerativeAI.Tools.Mcp;
using GenerativeAI.Types;

// Configure the filesystem MCP server
var documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

var transport = McpTransportFactory.CreateStdioTransport(
    name: "filesystem",
    command: "npx",
    arguments: new[] {
        "-y",
        "@modelcontextprotocol/server-filesystem",
        documentsPath
    }
);

// Configure options
var options = new McpToolOptions
{
    ConnectionTimeoutMs = 30000,  // 30 second timeout
    AutoReconnect = true,          // Reconnect if connection drops
    IncludeDetailedErrors = true   // Show detailed errors
};

// Create the MCP tool
await using var mcpTool = await McpTool.CreateAsync(transport, options);

Console.WriteLine(" Connected to filesystem MCP server!");

Step 3: Discover Available Tools

Let's see what the server can do:

// Get all available tools
var tools = mcpTool.GetAvailableFunctions();

Console.WriteLine($"\n Available tools: {tools.Count}");
foreach (var toolName in tools)
{
    var info = mcpTool.GetFunctionInfo(toolName);
    Console.WriteLine($"   {toolName}: {info.Description}");
}

Output:

 Available tools: 5
   read_file: Read the complete contents of a file
   read_multiple_files: Read multiple files simultaneously
   write_file: Create a new file or overwrite existing
   list_directory: List all files and directories
   search_files: Search for files by name pattern

Step 4: Integrate with Gemini

Now for the magic let's give Gemini access to these tools!

// Create Gemini model
var apiKey = Environment.GetEnvironmentVariable("GOOGLE_API_KEY")
    ?? throw new Exception("Please set GOOGLE_API_KEY environment variable");

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash);

// Add the MCP tools
model.AddFunctionTool(mcpTool);

// Enable automatic function calling
model.FunctionCallingBehaviour.AutoCallFunction = true;
model.FunctionCallingBehaviour.AutoReplyFunction = true;

Console.WriteLine("\n Gemini is ready with filesystem access!");

Step 5: Create an Interactive Chat

Let's build a conversational interface:

// Start chat session
var chat = model.StartChat();

// Helper method to chat with Gemini
async Task AskGemini(string prompt)
{
    Console.WriteLine($"\n You: {prompt}");
    Console.Write(" Gemini: ");

    var response = await chat.GenerateContentAsync(prompt);
    Console.WriteLine(response.Text());
}

// Example conversations
await AskGemini("What files are in my Documents folder?");
await AskGemini("Can you read my README.md file if it exists?");
await AskGemini("Search for all PDF files and tell me their names");
await AskGemini("Create a summary.txt file with a list of all text files");

Step 6: Add System Instructions

Make Gemini even better with context:

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash)
{
    SystemInstruction = @"
        You are a helpful file management assistant. When users ask about files:

        1. Always use the available filesystem tools
        2. Provide clear, concise summaries
        3. If you can't find something, suggest alternatives
        4. For large files, offer to summarize specific sections
        5. Be proactive - if you see related files, mention them

        Remember: You have access to read, write, list, and search files.
    "
};

Part 3: Advanced Patterns

Pattern 1: Multiple MCP Servers

Connect to several services at once:

var transports = new List<IClientTransport>
{
    // Filesystem access
    McpTransportFactory.CreateStdioTransport(
        "filesystem",
        "npx",
        new[] { "-y", "@modelcontextprotocol/server-filesystem", "/path" }
    ),

    // GitHub integration
    McpTransportFactory.CreateStdioTransport(
        "github",
        "npx",
        new[] { "-y", "@modelcontextprotocol/server-github" }
    ),

    // Slack integration
    McpTransportFactory.CreateHttpTransportWithAuth(
        "https://slack-mcp.example.com",
        Environment.GetEnvironmentVariable("SLACK_TOKEN")
    )
};

// Create all tools
var mcpTools = await McpTool.CreateMultipleAsync(transports);

// Add all to Gemini
foreach (var tool in mcpTools)
{
    model.AddFunctionTool(tool);
}

// Now Gemini can use ALL services!
await model.GenerateContentAsync(
    "Check if there are any open GitHub issues, " +
    "read the project README, and post a summary to Slack"
);

// Cleanup
foreach (var tool in mcpTools)
{
    await tool.DisposeAsync();
}

Pattern 2: Error Handling

Handle connection issues gracefully:

try
{
    var mcpTool = await McpTool.CreateAsync(transport, new McpToolOptions
    {
        ConnectionTimeoutMs = 10000,
        AutoReconnect = true,
        MaxReconnectAttempts = 3,
        ThrowOnToolCallFailure = false  // Don't crash on tool errors
    });

    // Use the tool
    var response = await model.GenerateContentAsync("List my files");
    Console.WriteLine(response.Text());
}
catch (TimeoutException)
{
    Console.WriteLine(" Connection timeout - is the MCP server running?");
}
catch (Exception ex)
{
    Console.WriteLine($" Error: {ex.Message}");
}

Pattern 3: Streaming Responses

Stream Gemini's responses for better UX:

model.AddFunctionTool(mcpTool);

Console.Write(" Gemini: ");

await foreach (var chunk in model.StreamContentAsync(
    "Read the largest file and summarize its contents"))
{
    Console.Write(chunk.Text());
}

Console.WriteLine();

Part 4: Real-World Examples

Example 1: Code Review Assistant

var transport = McpTransportFactory.CreateStdioTransport(
    "filesystem",
    "npx",
    new[] { "-y", "@modelcontextprotocol/server-filesystem", "./src" }
);

await using var mcpTool = await McpTool.CreateAsync(transport);

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash)
{
    SystemInstruction = @"
        You are a code review assistant. Analyze source code files for:
        - Code quality issues
        - Potential bugs
        - Performance improvements
        - Security vulnerabilities

        Provide specific, actionable feedback.
    "
};

model.AddFunctionTool(mcpTool);

var response = await model.GenerateContentAsync(
    "Review all C# files in the current directory and identify potential issues"
);

Console.WriteLine(response.Text());

Example 2: Documentation Generator

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash);
model.AddFunctionTool(mcpTool);

var response = await model.GenerateContentAsync(@"
    Read all the code files in this project, understand the architecture,
    and create a comprehensive README.md with:
    - Project overview
    - Setup instructions
    - API documentation
    - Usage examples
");

Console.WriteLine(" Documentation generated!");
Console.WriteLine(response.Text());

Example 3: Multi-Service Integration

// Connect to multiple services
var githubTransport = McpTransportFactory.CreateStdioTransport(
    "github", "npx", new[] { "-y", "@modelcontextprotocol/server-github" }
);

var filesystemTransport = McpTransportFactory.CreateStdioTransport(
    "filesystem", "npx",
    new[] { "-y", "@modelcontextprotocol/server-filesystem", "./" }
);

var tools = await McpTool.CreateMultipleAsync(new[]
{
    githubTransport,
    filesystemTransport
});

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash);
foreach (var tool in tools) model.AddFunctionTool(tool);

// Gemini can now coordinate across services!
await model.GenerateContentAsync(@"
    1. Check for open GitHub issues labeled 'bug'
    2. For each issue, check if we have a test file covering it
    3. Create a report summarizing gaps in test coverage
    4. Save the report to 'test-coverage-gaps.md'
");

Configuration Deep Dive

McpToolOptions Explained

var options = new McpToolOptions
{
    // How long to wait for connection (milliseconds)
    ConnectionTimeoutMs = 30000,

    // Automatically reconnect if connection drops
    AutoReconnect = true,

    // Maximum reconnection attempts before giving up
    MaxReconnectAttempts = 3,

    // Throw exception on tool call failures (vs. return error in response)
    ThrowOnToolCallFailure = false,

    // Include detailed error messages in responses
    IncludeDetailedErrors = true
};

Transport Factory for Reconnection

For better reconnection handling, use a factory function:

var mcpTool = await McpTool.CreateAsync(
    transportFactory: () => McpTransportFactory.CreateStdioTransport(
        "my-server",
        "npx",
        new[] { "-y", "@modelcontextprotocol/server-everything" }
    ),
    options: new McpToolOptions
    {
        AutoReconnect = true,
        MaxReconnectAttempts = 5
    }
);

The factory ensures a fresh transport is created for each reconnection attempt.

Available MCP Servers

Here are some popular MCP servers you can use right now:

Official Servers

Server	Description	Installation
filesystem	File operations (read, write, search)	`npx -y @modelcontextprotocol/server-filesystem`
github	GitHub integration (issues, PRs, repos)	`npx -y @modelcontextprotocol/server-github`
google-drive	Google Drive access	`npx -y @modelcontextprotocol/server-google-drive`
slack	Slack messaging	`npx -y @modelcontextprotocol/server-slack`
postgres	PostgreSQL database queries	`npx -y @modelcontextprotocol/server-postgres`
everything	Demo server with multiple tools	`npx -y @modelcontextprotocol/server-everything`

Community Servers

Browse hundreds more at: MCP Server Registry

Best Practices

1. Always Dispose Resources

// Good: Using statement
await using var mcpTool = await McpTool.CreateAsync(transport);

// Also good: Try-finally
var mcpTool = await McpTool.CreateAsync(transport);
try
{
    // Use mcpTool
}
finally
{
    await mcpTool.DisposeAsync();
}

2. Set Appropriate Timeouts

// Local servers: Short timeout
var localOptions = new McpToolOptions
{
    ConnectionTimeoutMs = 5000  // 5 seconds
};

// Remote servers: Longer timeout
var remoteOptions = new McpToolOptions
{
    ConnectionTimeoutMs = 30000  // 30 seconds
};

3. Enable Detailed Errors in Development

var options = new McpToolOptions
{
    IncludeDetailedErrors = true,  // Development
    // IncludeDetailedErrors = false  // Production
};

4. Use System Instructions

Guide Gemini on how to use tools effectively:

var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash)
{
    SystemInstruction = @"
        When using filesystem tools:
        - Always verify file existence before reading
        - Summarize large files instead of dumping full content
        - Suggest file locations if not found
        - Be cautious with write operations
    "
};

5. Implement Error Recovery

var options = new McpToolOptions
{
    AutoReconnect = true,
    MaxReconnectAttempts = 3,
    ThrowOnToolCallFailure = false  // Return errors gracefully
};

Troubleshooting

Problem: Server Won't Start

Error: Failed to connect to MCP server

Solutions:

# 1. Check if Node.js is installed
node --version

# 2. Try running the server manually
npx -y @modelcontextprotocol/server-filesystem /path

# 3. Increase timeout
var options = new McpToolOptions { ConnectionTimeoutMs = 60000 };

Problem: Tools Not Discovered

Error: GetAvailableFunctions() returns empty

Solutions:

// 1. Refresh tools
await mcpTool.RefreshToolsAsync();

// 2. Check connection
Console.WriteLine($"Connected: {mcpTool.IsConnected}");

// 3. Inspect server logs
// Look for errors in the console output

Problem: Function Calls Fail

Error: Tool returns errors

Solutions:

// 1. Enable detailed errors
var options = new McpToolOptions { IncludeDetailedErrors = true };

// 2. Inspect parameter schema
var info = mcpTool.GetFunctionInfo("tool-name");
Console.WriteLine(info.ParametersJsonSchema);

// 3. Test manually
var result = await mcpTool.CallAsync(new FunctionCall
{
    Name = "tool-name",
    Args = new JsonObject { ["param"] = "value" }
});

Complete Working Example

Here's a full application you can run right now:

using System;
using System.Threading.Tasks;
using GenerativeAI;
using GenerativeAI.Tools.Mcp;
using GenerativeAI.Types;

namespace GeminiMcpDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine(" Gemini MCP File Assistant\n");

            // 1. Setup MCP connection
            var docsPath = Environment.GetFolderPath(
                Environment.SpecialFolder.MyDocuments
            );

            var transport = McpTransportFactory.CreateStdioTransport(
                "filesystem",
                "npx",
                new[] { "-y", "@modelcontextprotocol/server-filesystem", docsPath }
            );

            var options = new McpToolOptions
            {
                ConnectionTimeoutMs = 30000,
                AutoReconnect = true,
                IncludeDetailedErrors = true
            };

            await using var mcpTool = await McpTool.CreateAsync(transport, options);
            Console.WriteLine(" Connected to filesystem MCP server");

            // 2. Show available tools
            Console.WriteLine("\n Available tools:");
            foreach (var tool in mcpTool.GetAvailableFunctions())
            {
                var info = mcpTool.GetFunctionInfo(tool);
                Console.WriteLine($"   {tool}: {info.Description}");
            }

            // 3. Create Gemini model
            var apiKey = Environment.GetEnvironmentVariable("GOOGLE_API_KEY");
            if (string.IsNullOrEmpty(apiKey))
            {
                Console.WriteLine("\n Please set GOOGLE_API_KEY environment variable");
                return;
            }

            var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash)
            {
                SystemInstruction = @"
                    You are a helpful file assistant. You can:
                    - List and search files
                    - Read file contents
                    - Write new files

                    Always be clear and concise in your responses.
                "
            };

            model.AddFunctionTool(mcpTool);
            model.FunctionCallingBehaviour.AutoCallFunction = true;
            model.FunctionCallingBehaviour.AutoReplyFunction = true;

            Console.WriteLine("\n Gemini ready! Type 'exit' to quit.\n");

            // 4. Interactive chat loop
            var chat = model.StartChat();

            while (true)
            {
                Console.Write(" You: ");
                var input = Console.ReadLine();

                if (string.IsNullOrEmpty(input) || input.ToLower() == "exit")
                    break;

                try
                {
                    Console.Write(" Gemini: ");
                    var response = await chat.GenerateContentAsync(input);
                    Console.WriteLine(response.Text() + "\n");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($" Error: {ex.Message}\n");
                }
            }

            Console.WriteLine("\n Goodbye!");
        }
    }
}

Run it:

dotnet run

Try these prompts:

"What files are in my Documents folder?"
"Read my README.md file"
"Search for all .txt files"
"Create a file called 'test.txt' with 'Hello, MCP!'"
"Find all PDF files and list their names"

What's Next?

Now that you've mastered MCP integration, here are some ideas to explore:

Build a knowledge base assistant - Connect to multiple document sources
Create a DevOps helper - Integrate GitHub, databases, and file systems
Make a personal assistant - Combine calendar, email, and task management
Build an analytics tool - Query databases and generate reports
Create custom MCP servers - Build your own tools and services!

Resources

MCP Integration Guide - Complete documentation
SDK Repository - Source code and examples
MCP Documentation - Official MCP docs
MCP Servers Registry - Browse available servers
Sample Projects - Working examples

Conclusion

MCP transforms Google Gemini from a chatbot into a powerful agent that can interact with real systems and services. Whether you're building a file assistant, a code reviewer, or a multi-service coordinator, MCP makes it incredibly simple.

The best part? The same API works for any MCP-compatible service. Learn it once, use it everywhere!

Got questions or built something cool? Drop a comment below! I'd love to hear what you're building with MCP!

Happy coding!

P.S. Want to see more examples? Check out the samples folder in the GitHub repo!

Found this helpful? Give the repository a on GitHub!

Google's Imagen and Veo 2 with C# .Net

Gunpal Jain — Thu, 03 Apr 2025 13:28:41 +0000

Generative AI is transforming how we create digital content. Google is at the forefront with powerful models like Imagen for stunning image generation and Veo 2 for creating high-quality, cinematic videos from text prompts.

If you're a .Net developer looking to integrate these capabilities into your applications, this guide will show you how to get started using Google's Image and Video generative models.

What are Imagen and Veo 2?

Imagen: Imagen is a state-of-the-art text-to-image diffusion model that excels at generating high-quality, photorealistic images from textual descriptions. Its ability to understand complex prompts and produce diverse and imaginative visuals makes it an invaluable tool for creatives, developers, and anyone looking to bring their ideas to life.
Veo 2: Google's state-of-the-art text-to-video generation model. It aims to create high-definition, coherent videos in various cinematic and visual styles, exceeding a minute in length. Veo 2 excels at understanding prompts, rendering realistic movement, and maintaining consistency across shots. It's currently available in Private Preview via Vertex AI.

Prerequisites

Before you dive into the code, make sure you have the following:

API Keys / Authentication:

For Imagen (via Google AI): You'll likely need an API key generated from Google AI Studio or your Google Cloud Console.
For Veo 2 (via Vertex AI): You need to authenticate using Application Default Credentials (ADC) or a service account key file (.json). Your Google Cloud project must also be allowlisted for the Veo 2 private preview.

Required NuGet Packages:

For this tutorial we will be using Google_GenerativeAI SDK

dotnet add package Google.Google_GenerativeAI
dotnet add package Google.Google_GenerativeAI.Auth

Imagen: Bringing Text to Life with Stunning Images

The Google_GenerativeAI SDK simplifies the interaction with Imagen, allowing you to focus on your creative vision rather than the underlying API intricacies. Here's a step-by-step guide:

1. Initialize the Google AI Client:
Create an instance of the GoogleAi client using your API key. This single line of code, powered by the SDK, manages the authentication and connection setup.

   var googleAi = new GoogleAi(apiKey);

2. Create the Imagen Model Instance:
Instantiate the Imagen model using your desired model name. The SDK handles the model selection and configuration.

   var imageModel = googleAi.CreateImageModel("imagen-3.0-generate-002");

3. Generate Images:
Use the GenerateImagesAsync method to generate images from a text prompt. The SDK abstracts the complex request formatting, allowing you to simply provide the prompt.

var prompt = "A peaceful forest clearing at sunrise";
var response = await imageModel.GenerateImagesAsync(prompt);

4. Process the Response:
The response will contain the generated images in base64 encoded strings. The SDK provides easy access to the image data, simplifying further processing.

foreach (var image in response. Predictions)
{
   //Save or Display Images

   //Convert To Bytes
   var bytes = Convert.FromBase64String(image.BytesBase64Encoded);   
   await File.WriteAllBytesAsync(filePath,bytes);
}

Veo 2: Crafting Dynamic Videos from Text

Veo 2 takes generative AI to the next level by enabling the creation of high-quality videos from text prompts. This powerful tool allows users to generate dynamic and engaging video content with ease.

Getting Started with Veo 2 and Vertex AI

Currently, Veo 2 is in private preview, meaning access is limited. To use Veo 2, you'll need to request allowlisting for your Vertex AI project. The SDK, in conjunction with Vertex AI, simplifies the interaction with the Veo 2 model.

1. Request Allowlisting:
Contact Google Cloud support to request allowlisting for your Vertex AI project.

2. Set Up Vertex AI:
Once your project is allowlisted, you'll need to set up Vertex AI and authenticate using a service account. The SDK facilitates this authentication process.

//Your preferred authentication mode
var authenticator =  new GoogleServiceAccountAuthenticator(serviceAccountJsonFile)

//Initialize VertexAI instance
var vertexAI = new VertexAI(projectId, region, authenticator:authenticator);

3. Create a Video Generation Model Instance:
Instantiate the VideoGenerationModel using the Veo 2 model name. The SDK simplifies model instantiation.

var veoModelId = VertexAIModels.Video.Veo2Generate001;
var model = vertexAI.CreateVideoGenerationModel(veoModelId);

4. Create a GenerateVideosRequest:
Define the video generation request, including the prompt, configuration, and other parameters. The SDK helps in creating and formatting the request.

var request = new GenerateVideosRequest()
{
    Model = "veo2-generate-001",
    Prompt = "A dog catching a ball",
    Config = new GenerateVideosConfig()
    {
        AspectRatio = VideoAspectRatio.LANDSCAPE_16_9,
        DurationSeconds = 555,
        EnhancePrompt = true,
        Fps = 24,
        NumberOfVideos = 1,
        PersonGeneration = VideoPersonGeneration.AllowAdult,
        Resolution = VideoResolution.HD_720P
    }
};

5. Generate Videos:
Use the GenerateVideosAsync method to initiate video generation. The SDK handles the API call and request management.

var operation = await model.GenerateVideosAsync(request);

6. Wait for the Video Generation Completion:
Video generation can take time, so you'll need to wait for the operation to complete. The SDK simplifies the handling of long-running operations.

var response = await model.AwaitForLongRunningOperation(operation.Name, (int)TimeSpan.FromMinutes(10).TotalMilliseconds).ConfigureAwait(false);

7. Process the Response:
Once the operation is complete, you can retrieve the generated video. The SDK provides easy access to the video data.

if (response.Done == true)
{
    await File.WriteAllBytesAsync("generated.mp4", response.Result.GeneratedVideos[0].Video.VideoBytes);
}

Conclusion

The Google_GenerativeAI SDK significantly simplifies the process of integrating Imagen and Veo 2 into your applications. By abstracting away the complexities of API interactions and providing intuitive interfaces, the SDK empowers developers to focus on their creative vision. By following the steps outlined in this guide, you can start exploring the capabilities of these models and unlock new possibilities for your creative projects. As Google continues to advance these technologies, we can expect even more exciting developments in the future. Remember that Veo 2 is currently in private preview, so ensure you apply for allowlisting to access its features.

Happy Coding!

Simplifying JSON Mode with Google Gemini and C# .Net

Gunpal Jain — Sun, 23 Mar 2025 00:14:58 +0000

Introduction

When working with AI models like Google Gemini, one of the most common tasks is parsing structured data returned from model responses. If you're a C# developer integrating Gemini into your applications, you'll want to know about the JSON handling capabilities in the Google_GenerativeAI SDK that make this process remarkably straightforward.

In this article, we'll explore how the Google_GenerativeAI SDK for C# simplifies JSON handling with Gemini models, helping you build more robust and maintainable AI-powered applications.

The Problem with Traditional JSON Handling

Before dedicated JSON modes in AI SDKs, developers had to:

Prompt the model to return JSON
Parse the raw text response
Handle edge cases where the AI might not return valid JSON
Convert the parsed JSON into usable C# objects

This process was error-prone and required extra validation code, making applications more complex than necessary.

Enter JSON Mode with Google GenerativeAI

The Google_GenerativeAI SDK for C# addresses these pain points by offering two powerful approaches to JSON handling:

Automatic JSON deserialization: Converting AI responses directly into C# objects
Manual JSON parsing: Providing more control for complex scenarios

Let's dive into each approach.

Automatic JSON Handling

Method 1: Using GenerateObjectAsync

The simplest way to get a JSON response from Gemini is using GenerateObjectAsync<T>. This method automatically deserializes the JSON response into an object of the specified type.

public class Person
{
    public string? Name { get; set; }
    public int Age { get; set; }
}

// Simple text prompt
var person = await googleAI.GenerateObjectAsync<Person>(
    "Give me a JSON object representing a person.");

if (person != null)
{
    Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}

The SDK provides multiple overloads to fit different scenarios:

// With a Content object
var content = new Content("Give me a JSON object representing a person.");
var person = await googleAI.GenerateObjectAsync<Person>(content);

// With a list of Part objects
var parts = new List<Part>
{
    new Part { Text = "Give me a JSON object representing a person." }
};
var person = await googleAI.GenerateObjectAsync<Person>(parts);

// With a full request for maximum flexibility
var request = new GenerateContentRequest();
request.AddText("Give me a JSON object representing a person.");
var person = await googleAI.GenerateObjectAsync<Person>(request);

Method 2: Using GenerateContentAsync with ToObject

If you need access to the full response but still want easy JSON deserialization:

var request = new GenerateContentRequest();
request.AddText("Give me a JSON object representing a person.");

var response = await googleAI.GenerateContentAsync<Person>(request);
var person = response.ToObject<Person>();

if (person != null)
{
    Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}

Method 3: Using UseJsonMode for Explicit JSON Handling

When you want to explicitly tell the SDK to expect a JSON response:

var request = new GenerateContentRequest();
request.UseJsonMode<Person>(); // Specifies the expected type
request.AddText("Give me a JSON object representing a person.");

var response = await googleAI.GenerateContentAsync(request);
var person = response.ToObject<Person>();

Manual JSON Parsing

For more complex scenarios where you need granular control:

// Create a request, optionally specifying MIME type and schema
var request = new GenerateContentRequest();
request.GenerationConfig = new GenerationConfig()
{
    ResponseMimeType = "application/json",
    ResponseSchema = (new Person()).ToSchema()
};
request.AddText("Generate details for three different people.");

// Parse response
var response = await googleAI.GenerateContentAsync(request);
var jsonBlocks = response.ExtractJsonBlocks();
var people = jsonBlocks.Select(block => block.ToObject<Person>());

foreach (var person in people)
{
    if (person != null)
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}

This approach is particularly useful when the response might contain multiple JSON blocks or when you need to process the JSON in a specific way.

Real-World Example: Building a Product Recommendation System

Let's see how JSON Mode can simplify a more complex scenario:

public class ProductRecommendation
{
    public string? ProductId { get; set; }
    public string? Name { get; set; }
    public string? Description { get; set; }
    public double RelevanceScore { get; set; }
    public List<string>? Tags { get; set; }
}

public async Task<List<ProductRecommendation>> GetRecommendationsForUser(string userId, string userPreferences)
{
    var request = new GenerateContentRequest();
    request.UseJsonMode<List<ProductRecommendation>>();
    request.AddText($"Based on user {userId} with preferences: {userPreferences}, " +
                   "provide a list of 5 product recommendations with relevance scores " +
                   "and tags indicating why they match the user's preferences.");

    var response = await googleAI.GenerateContentAsync(request);
    return response.ToObject<List<ProductRecommendation>>() ?? new List<ProductRecommendation>();
}

Benefits of Using JSON Mode

Type safety: Get compile-time checking for your model types
Reduced boilerplate: No need to write custom parsing logic
Improved reliability: The SDK handles edge cases and formatting issues
Better developer experience: Work with C# objects instead of raw strings
Easier integration: Streamlines connecting Gemini with your existing C# codebase

Best Practices

Define clear, well-structured C# classes that match your expected JSON response
Use nullable properties for fields that might not always be present
Start with GenerateObjectAsync for simple cases
Consider UseJsonMode when you need more control
Use ExtractJsonBlocks when working with multiple JSON objects in a single response
Include validation logic for business-critical applications

Conclusion

The JSON handling capabilities in the Google_GenerativeAI SDK for C# significantly simplify working with structured data from Gemini models. By providing both automatic deserialization and manual parsing options, the SDK caters to a wide range of use cases, from simple data retrieval to complex multi-object scenarios.

As AI becomes increasingly integrated into our applications, tools like these that bridge the gap between AI outputs and conventional programming paradigms will be essential for developer productivity and application reliability.

Have you used JSON Mode with Google Gemini in your projects? Share your experiences and tips in the comments below!

Google Gemini's Multimodal Live API with C# .Net

Gunpal Jain — Sat, 22 Mar 2025 23:39:12 +0000

Real-time communication with AI models opens up exciting possibilities for creating interactive applications. Google's Gemini models now support live, multimodal interactions. In this article, I'll walk through how to use this powerful capability to build responsive, voice-enabled applications using Google_GenerativeAI SDK for C# .NET.

Introducing the Multimodal Live API

The Google_GenerativeAI SDK has recently expanded with the Google_GenerativeAI.Live package, which provides a seamless interface to the Google Multimodal Live API. This implementation leverages WebSockets to enable real-time, bidirectional communication with Gemini models, allowing for dynamic exchange of both text and audio data.

What makes this API particularly valuable is its ability to handle multiple modalities simultaneously, making it perfect for applications that require natural conversations through text, voice, or a combination of both.

Key Features at a Glance

The Google_GenerativeAI.Live package comes with a robust set of features designed to support sophisticated application development:

Real-time, bidirectional communication for truly interactive experiences
Support for multiple response modalities (text and audio)
Fully asynchronous operations to maintain application responsiveness
Event-driven architecture for handling various stages of interaction
Built-in audio streaming capabilities with configurable parameters
Custom tool integration to extend functionality
Comprehensive error handling and reconnection support
Flexible configuration options for generation settings, safety parameters, and system instructions

Getting Started

Let's walk through the process of setting up and using the Multimodal Live API in your C# application.

Installation

First, you need to install the NuGet package:

Install-Package Google_GenerativeAI.Live
Install-Package NAudio

Basic Setup and Usage

Here's how to create a basic implementation that handles both text and audio:

// Create the client with the desired configuration
var client = new MultiModalLiveClient(
    platformAdapter: new GoogleAIPlatformAdapter(), 
    modelName: "gemini-1.5-flash-exp", 
    generationConfig: new GenerationConfig 
    { 
        ResponseModalities = { Modality.TEXT, Modality.AUDIO } 
    }, 
    safetySettings: null, 
    systemInstruction: "You are a helpful assistant."
);

// Subscribe to events
client.Connected += (s, e) => Console.WriteLine("Connected to Gemini!");
client.TextChunkReceived += (s, e) => Console.WriteLine($"Gemini: {e.TextChunk}");
client.AudioChunkReceived += (s, e) => Console.WriteLine($"Audio received: {e.Buffer.Length} bytes");

// Connect and send messages
await client.ConnectAsync();
await client.SentTextAsync("Hello, Gemini!");

Streaming Audio in Real-Time

One of the most powerful features of the Multimodal Live API is the ability to stream audio directly to Gemini as it's being captured, without waiting for a complete recording:

// Setup real-time audio streaming Using NAudio
_waveIn = new WaveInEvent { WaveFormat = new WaveFormat(16000, 1) };
_waveIn.DataAvailable += async (s, e) => {
    // Send audio chunks as they arrive
    if (_isListening)
    {
        await _client.SendAudioAsync(
            audioData: e.Buffer,
            audioContentType: "audio/pcm; rate=16000"
        );
    }
};

// Start listening and streaming
public void StartRealTimeListening()
{
    _isListening = true;
    _waveIn.StartRecording();
    Console.WriteLine("Streaming audio to Gemini in real-time...");
}

// Stop listening
public void StopListening()
{
    _isListening = false;
    _waveIn.StopRecording();
}

This approach creates a much more responsive experience, as the model can begin processing speech before the user has finished talking. It's particularly useful for creating natural-feeling voice assistants that can provide feedback with minimal latency.

Real-Time Audio Playback

To complement real-time audio streaming, here's how to set up immediate playback of Gemini's audio responses:

private BufferedWaveProvider _bufferedWaveProvider;
private WaveOutEvent _waveOut;

// Setup audio playback system
private void InitializeAudioPlayback()
{
    var waveFormat = new WaveFormat(16000, 16, 1);
    _bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
    _waveOut = new WaveOutEvent();
    _waveOut.Init(_bufferedWaveProvider);
}

// Handle incoming audio chunks for immediate playback
client.AudioChunkReceived += (s, e) => {
    // Add received audio to buffer
    _bufferedWaveProvider.AddSamples(e.Buffer, 0, e.Buffer.Length);

    // Start playback if not already playing
    if (_waveOut.PlaybackState != PlaybackState.Playing)
    {
        _waveOut.Play();
    }
};

// Handle playback completion
client.AudioReceiveCompleted += (s, e) => {
    Console.WriteLine("Audio response complete");
    // Optional: wait for buffered audio to finish playing
};

This approach creates a seamless conversational experience by playing audio responses as soon as they arrive, rather than waiting for the complete response. The BufferedWaveProvider handles the streaming nature of the audio data, ensuring smooth playback even as new chunks are being received.

Event-Driven Architecture

The MultiModalLiveClient exposes several key events:

// Core connection events
client.Connected += (s, e) => Console.WriteLine("Connected!");
client.Disconnected += (s, e) => Console.WriteLine("Disconnected");
client.ErrorOccurred += (s, e) => Console.WriteLine($"Error: {e.Exception.Message}");

// Data events
client.TextChunkReceived += (s, e) => ProcessTextChunk(e.TextChunk);
client.AudioChunkReceived += (s, e) => StoreAudioChunk(e.Buffer);
client.AudioReceiveCompleted += (s, e) => PlayStoredAudio();

This event-based approach makes it easy to build responsive applications that can handle the asynchronous nature of real-time communication.

Advanced Features and Configurations

Customize how Gemini generates responses:

// Generation config
var generationConfig = new GenerationConfig
{
    Temperature = 0.7f,
    TopP = 0.95f,
    ResponseModalities = { Modality.TEXT, Modality.AUDIO }
};

// Safety settings
var safetySettings = new List<SafetySetting>
{
    new SafetySetting
    {
        Category = HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        Threshold = HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
    }
};

// System instructions
var systemInstruction = "You are a helpful technical support assistant.";

Building a Simple Voice Assistant

Here's a quick example bringing it all together in a voice assistant application:

public class SimpleVoiceAssistant
{
    private MultiModalLiveClient _client;
    private WaveInEvent _waveIn;
    private BufferedWaveProvider _bufferedWaveProvider;
    private WaveOutEvent _waveOut;
    private bool _isListening = false;

    public async Task InitializeAsync()
    {
        // Initialize client
        _client = new MultiModalLiveClient(
            platformAdapter: new GoogleAIPlatformAdapter(), 
            modelName: "gemini-1.5-flash-exp", 
            generationConfig: new GenerationConfig 
            { 
                ResponseModalities = { Modality.TEXT, Modality.AUDIO } 
            }, 
            safetySettings: null, 
            systemInstruction: "You are a helpful voice assistant."
        );

        // Set up events
        SetupEvents();

        // Initialize audio
        SetupAudio();

        // Connect
        await _client.ConnectAsync();
    }

    private void SetupEvents()
    {
        _client.TextChunkReceived += (s, e) => Console.WriteLine($"Gemini: {e.TextChunk}");
        _client.AudioChunkReceived += HandleAudioChunk;
    }

    private void SetupAudio()
    {
        // Input setup
        _waveIn = new WaveInEvent { WaveFormat = new WaveFormat(16000, 1) };
        _waveIn.DataAvailable += HandleMicrophoneData;

        // Output setup
        var waveFormat = new WaveFormat(16000, 16, 1);
        _bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
        _waveOut = new WaveOutEvent();
        _waveOut.Init(_bufferedWaveProvider);
    }

    private async void HandleMicrophoneData(object sender, WaveInEventArgs e)
    {
        if (_isListening)
        {
            await _client.SendAudioAsync(e.Buffer, "audio/pcm; rate=16000");
        }
    }

    private void HandleAudioChunk(object sender, AudioChunkEventArgs e)
    {
        _bufferedWaveProvider.AddSamples(e.Buffer, 0, e.Buffer.Length);

        if (_waveOut.PlaybackState != PlaybackState.Playing)
        {
            _waveOut.Play();
        }
    }

    public void StartListening()
    {
        _isListening = true;
        _waveIn.StartRecording();
    }

    public void StopListening()
    {
        _isListening = false;
        _waveIn.StopRecording();
    }
}

Check out the complete WPF Sample with Source Code

Conclusion

The Google_GenerativeAI.Live package brings powerful real-time, multimodal capabilities to C# developers. By leveraging WebSockets and an event-driven architecture, it enables the creation of highly interactive applications that can seamlessly blend text and voice interactions with Gemini's advanced AI capabilities.

Whether you're building a voice assistant, an interactive chat application, or a multimodal customer service solution, this API provides the foundation you need to create responsive, engaging experiences.

Have you built something interesting with the Multimodal Live API? I'd love to hear about your experiences in the comments!

Google Vertex RAG Engine with C# .Net

Gunpal Jain — Sat, 22 Mar 2025 22:40:29 +0000

What is RAG?

Ever asked an AI chatbot about your company's products or policies only to get a generic answer or worse - confidently incorrect information? This highlights the core limitation of standard LLMs: they know general information but nothing specific about your organization.

Retrieval Augmented Generation (RAG) solves this problem elegantly:

Without RAG:

User: "What's our refund policy for premium customers?"

AI: Provides generic refund information or makes up details

With RAG:

User: "What's our refund policy for premium customers?"

AI: "According to our current policy (updated last month), premium customers can request refunds within 60 days of purchase with no questions asked. Standard customers have a 30-day window."

How RAG Works

RAG enhances AI by connecting it to your specific knowledge:

When a question arrives, RAG searches your documents for relevant information
It provides this context to the AI along with the original question
The AI generates a response grounded in your actual data

It's like giving your AI assistant access to your company's documentation before it answers questions.

Why RAG Matters for Developers

Accuracy: Responses based on your actual data, not guesswork
Freshness: Add new documents anytime without retraining models
Privacy: Your data stays separate from the model
Specificity: Handle domain-specific questions with confidence

For practical AI applications in business settings, RAG isn't just nice to have—it's essential for delivering reliable, specific answers.

RAG Implementation Components

Building a RAG application typically involves managing several components:

Document processing and chunking
Embedding generation
Vector database management
Retrieval mechanisms
Context integration with LLMs

Google Vertex RAG Engine integrates these components into a managed service, providing a unified approach to RAG implementation.

Key Features of Vertex RAG Engine

Integrated Architecture

Vertex RAG provides an end-to-end solution that integrates:

Document processing capabilities
Embedding generation using Google's models
Vector storage management
Retrieval mechanisms
Integration with generative models

Infrastructure Management

The managed service approach helps reduce infrastructure overhead by handling:

Vector database scaling
Embedding pipeline execution
Retrieval algorithm optimization
Component integration

Data Source Connectors

Vertex RAG supports several data sources:

Google Cloud Storage
Slack
Jira
SharePoint
Direct uploads

Easy Implementation with Google_GenerativeAI SDK

Let's walk through the complete process of implementing RAG with Google Vertex RAG Engine using C#.

1. Initialize Vertex AI

The first step is to initialize the Vertex AI client with appropriate authentication:

// Initialize Vertex AI with authentication
var vertexAi = new VertexAI(projectId, region,
    authenticator:
    new GoogleServiceAccountAuthenticator("path/to/your/service/account.json")
    // or another authenticator that suits your credentials
);

You'll need to ensure your credentials have the necessary IAM permissions:

Vertex AI RAG Data Service Agent
Vertex AI User
Secret Manager Secret Accessor
AI Platform Developer

2. Create a RAG Manager

Next, create a RAG Manager to handle corpus operations:

var ragManager = vertexAi.CreateRagManager();

3. Create Your Knowledge Base (Corpus)

Now you can create a corpus that will serve as your knowledge base:

var corpus = await ragManager.CreateCorpusAsync("My New Corpus", "My description");

You can also specify a custom vector database if needed:

// Example with Pinecone
var corpus = await ragManager.CreateCorpusAsync(
    "My New Corpus", 
    "My description",
    pineconeConfig: new RagVectorDbConfigPinecone(...),
    apiKeyResourceName: "projects/my-project/secrets/pinecone-key/versions/1"
);

4. Import Data into the Corpus

Import your data from a specified source:

// Import from Google Cloud Storage
var fileSource = new GcsSource() 
{ 
    Uris = { "gs://your-bucket/your-document.pdf" }
};
await ragManager.ImportFilesAsync(corpus.Name, fileSource);

// Or upload a local file directly
await ragManager.UploadLocalFileAsync(corpus.Name, "path/to/local/file.pdf");

The SDK supports multiple data sources:

Google Cloud Storage
Slack
Jira
SharePoint
Direct file uploads

5. Create a Generative Model with RAG Configuration

Connect a generative model to your knowledge base:

var model = vertexAi.CreateGenerativeModel(
    VertexAIModels.Gemini.Gemini2Flash, 
    corpusIdForRag: corpus.Name
);

6. Generate Content

Now you can generate responses grounded in your knowledge base:

// For a one-time response
var result = await model.GenerateContentAsync("How do I reset my password?");
Console.WriteLine(result.Text);

// Or create a conversational chat
var chat = model.StartChat();
var response = await chat.GenerateContentAsync("Tell me about our product features.");

The Fastest Path from Idea to Working Application

With the combination of Google Vertex RAG Engine and the Google_GenerativeAI SDK, you can go from concept to working prototype in hours, not weeks:

Morning: Set up your Google Cloud project and install the SDK
Midday: Create your corpus and import initial documents
Afternoon: Connect to models and test your first queries
Next day: Refine and expand your application

Compare this to traditional approaches that might require:

Weeks of architecture discussions
Days of infrastructure setup
Complex integration between multiple services
Ongoing maintenance of various components

Real-World Implementation: Documentation to Q&A System in Minutes

Here's how you can build a complete RAG application that scrapes any documentation website, creates a knowledge base, and provides an instant question-answering system. The full source code is available in the Google_GenerativeAI samples repository.

What This Demo Does

This demo automates the entire RAG application pipeline:

It scrapes content from any documentation website you specify
Creates a knowledge base (corpus) from that content
Connects a Gemini model to this knowledge base
Provides an interactive chat interface where you can ask questions about the documentation

All of this happens with minimal code, thanks to the power of Google Vertex RAG Engine and the simplicity of the Google_GenerativeAI SDK.

Key Code Components

1. Initialization

Setting up the Vertex AI client and RAG manager:

public VertexRagDemo(string projectId, string region, string serviceAccountFilePath)
{
    _projectId = projectId;
    _region = region;
    var authenticator = new GoogleServiceAccountAuthenticator(serviceAccountFilePath);
    _vertexAi = new VertexAI(projectId, region, authenticator: authenticator);
    _ragManager = _vertexAi.CreateRagManager();
}

2. Creating or Retrieving a Corpus

The demo intelligently checks if a corpus already exists before creating a new one:

private async Task<RagCorpus> GetOrCreateCorpus(string corpusName, string corpusDescription)
{
    try
    {
        var existingCorpus = await _ragManager.GetCorpusAsync(corpusName);
        if (existingCorpus != null)
        {
            Console.WriteLine($"Corpus '{corpusName}' already exists.");
            this._corpus = existingCorpus;
            return existingCorpus;
        }

        return existingCorpus;
    }
    catch (Exception ex)
    {
        var newCorpus = await _ragManager.CreateCorpusAsync(corpusName, corpusDescription);
        this._corpus = newCorpus;
        Console.WriteLine($"Corpus '{_corpus.Name}' created.");

        return newCorpus;
    }
}

3. Web Scraping and Content Import

The demo uses a parallel web crawler to efficiently fetch content from documentation sites:

private async Task ScrapeAndImportData(string url)
{
    Console.WriteLine("Crawling documentation...");
    var crawler = new ParallelWebCrawler(url);
    var textList = await crawler.CrawlUrlsParallel(url);

    // Process documents in parallel for faster importing
    await Parallel.ForEachAsync(textList, new ParallelOptions() { MaxDegreeOfParallelism = 50 }, 
        async (text, ct) =>
        {
            try
            {
                // Create temp file and upload to corpus
                var tmp = Path.GetTempFileName() + ".html";
                await File.WriteAllTextAsync(tmp, text, ct);
                await _ragManager.UploadLocalFileAsync(_corpus.Name, tmp, cancellationToken: ct);
            }
            catch(Exception ex)
            {
                Console.WriteLine($"Error importing file: {ex.Message}");
            }
        });

    Console.WriteLine("Data import completed.");
}

4. Setting Up the Generative Model with RAG

Connecting a Gemini model to the knowledge base with a single line of code:

// Create generative model with RAG enabled
_model = _vertexAi.CreateGenerativeModel(
    VertexAIModels.Gemini.Gemini2Flash, 
    corpusIdForRag: _corpus.Name
);

5. Interactive Chat Interface

A simple but effective interactive chat interface for testing the knowledge base:

private async Task StartQaChat()
{
    var chat = _model.StartChat();

    while (true)
    {
        Console.Write("Ask a question (or 'exit'): ");
        string question = Console.ReadLine();

        if (question.ToLower() == "exit")
        {
            break;
        }

        try
        {
            var result = await chat.GenerateContentAsync(question);
            Console.WriteLine($"Answer: {result.Text}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

How to Use the Demo

To use this demo, simply create an instance and start it:

// Initialize the demo with your Google Cloud project details
var demo = new VertexRagDemo(
    projectId: "your-project-id",
    region: "us-central1",
    serviceAccountFilePath: "path/to/service-account.json"
);

// Start the demo with a documentation URL to scrape
await demo.StartDemo(
    documentationsUrl: "https://your-documentation-site.com",
    corpusName: "ProductDocumentation",
    corpusDescription: "Knowledge base for product documentation"
);

For the complete implementation, including the ParallelWebCrawler class and additional utilities, visit the Google_GenerativeAI samples repository on GitHub.

Practical Applications

This demo can be immediately adapted for various real-world scenarios:

Technical Documentation Assistant: Point it at your product documentation to create an instant support chatbot
Policy Guide: Use it with company policies to help employees navigate complex procedures
API Explorer: Target your API documentation to help developers understand your services
Training Materials: Convert training websites into interactive Q&A systems

The best part? Google Vertex RAG Engine handles all the complex vector operations, semantic search, and retrieval optimization behind the scenes, while the Google_GenerativeAI SDK provides a clean, intuitive interface that makes implementation straightforward for C# developers.

Start Building Today

If you want to build a RAG application that provides accurate, context-aware responses based on your specific knowledge, Google Vertex RAG Engine with the Google_GenerativeAI SDK is simply the easiest path forward.

No other approach offers the same combination of:

Minimal development effort
End-to-end integration
Managed infrastructure
Simple, intuitive API
Rapid time to implementation

The next time you consider building a RAG application, remember that Google Vertex RAG Engine and the Google_GenerativeAI SDK for C# provide the simplest path from idea to working solution.

Side Note: I used AI to convert my ideas into presentable blog post. This blog post is created for education purpose.

Google Gemini with C# .NET: Function Calling Overdrive!

Gunpal Jain — Wed, 12 Mar 2025 19:50:15 +0000

Introduction

Hey everyone! Ready to make Google Gemini do some real work? We're diving into function calling, which lets you give Gemini its own set of tools. Think of it like teaching your AI to use your code to solve problems!

I'm Gunpal, the person who created the Google_GenerativeAI SDK for .Net. And I'm thrilled to show you how to make Gemini do amazing things in your C# .NET apps. We'll start by exploring ways to declare and use the "Function Tools", and after that we'll build a super cool project: A Javascript Code Generator and Executor. Get ready to turn Gemini into a code-executing wizard!

Part 1: Easy Ways to Add Tools to Gemini

We've got a few ways to add tools, and they're all designed to be simple and powerful using C# Attributes.

1. QuickTools

Got a quick task for Gemini? QuickTools are your go-to. They turn your methods into tools in a flash!

//Define a method, it can be a named method
var doThisJob = (async ([Description("Find a student's info")] StudentQuery query) =>
{
    // ... your code to find student info ...
    return new StudentInfo { Name = query.StudentName, Grade = "A+" };
});

//Create a QuickTool
var myTool = new QuickTool(doThisJob, "FindStudent", "Get a student's info.");

//Initialize Generative Model
var gemini = new GenerativeModel(apiKey: "YOUR_API_KEY", GoogleAIModels.Gemini2Flash);

//Add Function Tool into model
gemini.AddFunctionTool(myTool);

//Usage
var answer = await gemini.GenerateContentAsync("What's John's grade?").ConfigureAwait(false);

Why it's cool: It's the fastest way to add a simple tool!

2. Turn Methods into Function Tools with Source Code Generation

Want a cleaner, more efficient way to add tools? Just Annotate your methods with FunctionTool attribute, and our built-in source generator will do the rest! It takes care of all the behind-the-scenes work, like creating JSON schemas and serializers, making everything run smoother and faster. and Guess what! it will be NativeAOT/Trimming compatible right away!

//Define Method
[FunctionTool(GoogleFunctionTool = true)]
[Description("Get a page from a book.")]
public static Task<string> GetBookPageAsync(string book, int page, CancellationToken cancellationToken=default)
{
    return Task.FromResult("The sun was shining...");
}

//Initialize GenerativeModel
var gemini = new GenerativeModel(apiKey: "YOUR_API_KEY", GoogleAIModels.Gemini2Flash);

//Create instance of auto generated Tools class
var myTools = new Tools([GetBookPageAsync]);

//Add to model
gemini.AddFunctionTool(myTools);

// Example usage:
var result = await gemini.GenerateContentAsync("Give me the first page of 'The Adventures of Tom Sawyer'").ConfigureAwait(false);

Why it's awesome: Super clean, efficient, and the source generator handles all the technical details.

3. Making Reusable Plugins with Interfaces

If you need to create reusable sets of functions, using an interface is perfect. It's like building a plugin that you can use over and over! We use the GenerateJsonSchema attribute on the interface.

//Declare Interface
[GenerateJsonSchema(GoogleFunctionTool = true)]
public interface IWeatherTools
{
    [Description("Get the weather.")]
    WeatherInfo GetWeather(
        [Description("City name")]
        string city);
}

//Implement the interface
public class WeatherInfo
{
    public string City { get; set; }
    public string Temp { get; set; }
}

public class WeatherService : IWeatherTools
{
    public WeatherInfo GetWeather(string city)
    {
        return new WeatherInfo { City = city, Temp = "75 degrees" };
    }
}

//Initialize the service/tool class
var weatherService = new WeatherService();

//Initialize Gemini Model
var gemini = new GenerativeModel(apiKey: "YOUR_API_KEY", GoogleAIModels.Gemini2Flash);

//Add function tool to model
var weatherTool = weatherService.AsGoogleFunctionTool();
gemini.AddFunctionTool(weatherTool);

// Example usage:
var result = await gemini.GenerateContentAsync("What is the weather in London?").ConfigureAwait(false);

Why it's awesome: It's super organized and great for building reusable plugins with multiple functions.

Controlling How Gemini Uses Tools

You can tell Gemini how to use your tools.

gemini.FunctionCallingBehaviour = new FunctionCallingBehaviour
{
    AutoCallFunction = false, // For manual control over execution, Gemini suggests the tool and SDK will not execute the function
    AutoReplyFunction = true,  // Reply back with the function results automatically
    AutoHandleBadFunctionCalls = false // Don't try to fix mistakes by Gemini.
};

Part 2: Let's Build a Javascript Code Runner!

Now, let's build something truly exciting! We'll make Gemini write Javascript code to solve user-defined problems and then run it using the Jint library. Imagine telling Gemini, "Calculate the 4th power of the 67th prime number," and it does it!

Step 1: Create a Console App and Install the Necessary Packages

First, create a new console application targeting .NET 8.0 or later. Then, install the Google_GenerativeAI.Tools and Jint NuGet packages:

dotnet new console -f net8.0
dotnet add package Google_GenerativeAI.Tools
dotnet add package Jint

Step 2: Make a Function to Run Code

We'll create a function that takes Javascript code and runs it. Let's start with a simple example:

public static string RunJavascript(string code)
{
    try
    {
        var engine = new Engine();
        var result = engine.Evaluate(code).ToString();
        return result;
    }
    catch (JavaScriptException ex)
    {
        return $"Oops! Error: {ex.Message}";
    }
}

// Example usage:
// var result = RunJavascript("2+2");

Now, let's create a more sophisticated version that captures console output and handles various data types, and add description for Google Gemini to understand it.

//Description attributes for LLM to understand the use case of Tool
[Description("this function executes javascript code. pass any javascript code to execute.")]
public string? RunJavascriptCode([Description("Javascript code to execute")] string code)
{
    //Initialize Javascript Engine
    using var engine = new Engine();
    var sb = new StringBuilder();

    //Console outputs client side
    Console.WriteLine("Result from Javascript Engine:");

    //console.log definition
    engine.SetValue("console", new
    {
        log = new Action<object>(o =>
        {
            var output = o switch
            {
                JsValue jsValue when jsValue.IsString() => jsValue.AsString(),
                JsValue jsValue => jsValue.ToObject()?.ToString() ?? string.Empty,
                string str => str,
                _ => JsonSerializer.Serialize(o)
            };
            Console.WriteLine(output);
            sb.AppendLine(output);
        })
    });

    //execute the code
    var evaluationResult = engine. Evaluate(code);

    //return the value with correct data type
    return evaluationResult.Type switch
    {
        Types.Null => sb.ToString(),
        _ when evaluationResult.IsArray() => evaluationResult.AsArray()
            .Select(j => j.ToObject())
            .Where(obj => obj != null)
            .ToList(),
        _ => evaluationResult.ToObject()
    };
}

// Example usage:
var result = RunJavascriptCode("console.log('Hello from Jint!');

Step 3: Integrate with Gemini and Run the App

Here's the code to set up Gemini and run the Javascript code:

using GenerativeAI.Tools;
using Jint;
using Jint.Runtime;
using Jint.Runtime.Interop;
using System.Text;
using System.Text.Json;

// ... (Your RunJavascriptCode function here) ...

//Initialize Generative Model
var apiKey = Environment.GetEnvironmentVariable("GOOGLE_API_KEY", EnvironmentVariableTarget.User);
restart:
var model = new GenerativeModel(apiKey, GoogleAIModels.Gemini2Flash);


var javascriptExecutor = new QuickTool(RunJavascriptCode);

//Create a multi turn chat session
var chat = model.StartChat();

//Add executor to the chat
chat.AddFunctionTool(javascriptExecutor);

//Specify System instruction
chat.SystemInstruction = "Your job is to create javascript code and pass it to RunJavascriptCode for execution. \r\n- Always use RunJavascriptCode function to execute the javascript code.\r\n- use console.log to print the results.";

//Write some information to Console to make some sense
Console.WriteLine(
    "Tell me what to do, and I'll whip up some JavaScript magic to get it done! For example, I can count from 1 to 100.");
Console.WriteLine("Examples:");
Console.WriteLine("Print fibonacci numbers up to 100");
Console.WriteLine("Print the first 100 prime numbers in reverse order");
Console.WriteLine("calculate the 4th power of 67th prime number");
Console.WriteLine("calculate the acceleration due to gravity on mars");
Console.WriteLine("** Note: If I start to hallucinate or get confused. Just type restart and press enter!");

//Start Loop
while (true)
{
    //Input Prompt
    Console.WriteLine();
    Console.WriteLine("Input: ");
    var input = Console.ReadLine();
    if(input == "restart")
        goto restart;

    var prompt =
        $"\r\nExecute the javascript code for this task:\r\n\r\n{input}\r\n\r\n";

    //Execute    
    var result = await chat.GenerateContentAsync(prompt).ConfigureAwait(false);

    //Print Results
    Console.WriteLine();
    Console.Write("Result from Gemini:\r\n");
    Console.WriteLine(result.Text());
}

Full Source code sample is available here

Conclusion

And there you have it! We've successfully transformed Google Gemini into a powerful Javascript code executor, all thanks to the magic of function tools and the Google_GenerativeAI SDK as well as Jint. With just a few lines of code, you can bridge the gap between AI-generated code and real-world execution.

This example showcases the incredible flexibility and power of function calling. Whether you're building complex AI-powered applications or simply exploring the possibilities of generative AI, the Google_GenerativeAI SDK provides the tools you need to bring your ideas to life.

Remember, the possibilities are endless. You can extend Gemini's capabilities with your own custom functions, integrate it with existing systems, and create truly intelligent applications that solve real-world problems.

Happy coding!

Side Note: I used Gemini help to organise my ideas into presentable blog post and English is not my first language. This post is intended to educate beginners in A.I.