👁 Image
Google_GenerativeAI.Tools 3.6.6

Google_GenerativeAI.Tools

👁 NuGet
👁 License: MIT

Google_GenerativeAI.Tools – README

A comprehensive toolkit to seamlessly integrate and structure your Google Gemini function calls in C#. Google_GenerativeAI.Tools is offered as part of the Google_GenerativeAI SDK, supporting multiple modes of usage: either through reflection-based approaches or via code generation.

Table of Contents

1. Installation
2. Approaches
   • 1. Reflection-Based
     • Examples
   • 2. Code Generator-Based
     • 2.1 Individual Methods
     • 2.2 Interface-Based
3. Comparison
4. Contributing
5. License

Introduction

Google_GenerativeAI.Tools streamlines how you define, discover, and call your functions for Google Gemini.

Key features:

• Flexible reflection-based or code generation-based approaches.
• Automatic JSON schema generation for advanced scenarios.
• Strong typing and maintainability for large projects.
• NativeAOT-friendly APIs to ensure trimming safety.

Installation

1. Install the NuGet package (assuming it's available on NuGet.org):

   dotnet add package Google.GenerativeAI.Tools
   

2. Reference the package in your project file:

   <ItemGroup>
    <PackageReference Include="Google.GenerativeAI.Tools" Version="x.x.x" />
   </ItemGroup>
   

3. Restore packages:

   dotnet restore
   

Approaches

1. Reflection-Based

This method depends on runtime inspection of methods or delegates to generate the schema and create function tools.

Pros

• Rapid development.
• Minimal boilerplate, ideal for smaller or proof-of-concept projects.

Cons

• Requires manual handling of complex serialization contexts (e.g., JsonSerializerContext) for NativeAOT.
• Less structured than code generation.

Examples (Reflection-Based)

Use [QuickTool] or [QuickTools] to define reflection-based tools:

public record StudentRecord
{
 public string StudentId { get; set; }
 public string FullName { get; set; }
 // ...
}

// Reflection-based delegate
var func = (async ([Description("Query to retrieve student record")] string fullName) =>
{
 // Implementation detail
 return new StudentRecord
 {
 StudentId = "12345",
 FullName = fullName
 };
});

// Create QuickTool
var quickFt = new QuickTool(func, "GetStudentRecordAsync", "Returns the student record");

var model = new GenerativeModel(/* your config */);
model.AddFunctionTool(quickFt);

// Usage
var result = await model.GenerateContentAsync("What's the student record for John Joe?");
Console.WriteLine(result.Text());

2. Code Generator-Based

Code generation automatically produces schemas and extension methods, saving you from manually dealing with reflection or serializer contexts.

Pros

• Automatic JSON schema creation (bypassing reflection).
• NativeAOT ready with minimal extra configuration.
• Clean, strongly typed approach for large or complex projects.

Cons

• Additional codegen step required.
• Slightly steeper initial setup.

2.1 Individual Methods

Decorate your methods with [FunctionTool] to generate the needed schemas and integrate them:

[FunctionTool(GoogleFunctionTool = true)]
[Description("Retrieves content of a specific book page")]
public static Task<string> GetBookPageContentAsync(
 string bookName, 
 int pageNumber, 
 CancellationToken cancellationToken = default)
{
 // Implementation
 return Task.FromResult($"Page {pageNumber} of {bookName}");
}

//Usage

var tools = new Tools([GetBookPageContentAsync]);
generativeModel.AddFunctionTool(tools);

Generated code will handle JSON schema definitions and produce extension methods to register with your GenerativeModel.

2.2 Interface-Based

Build an interface to define one or more related methods. The code generator scans [GenerateJsonSchema] attributes to build tooling and registration code:

[GenerateJsonSchema(GoogleFunctionTool = true)]
public interface IWeatherFunctions
{
 [Description("Get current weather in a location")]
 Weather GetCurrentWeather(
 [Description("City and state, e.g. San Francisco, CA")]
 string location, 
 Unit unit = Unit.Celsius);
 // ... 
}

public class WeatherService : IWeatherFunctions
{
 public Weather GetCurrentWeather(string location, Unit unit = Unit.Celsius)
 {
 return new Weather
 {
 Location = location,
 Temperature = 20,
 Unit = unit
 };
 }
}

// Register after code generation
var weatherService = new WeatherService();
var googleTool = weatherService.AsGoogleFunctionTool();
model.AddFunctionTool(googleTool);

Interface Grouping
Group multiple functions in one interface, effectively creating a reusable “plugin.”

Comparison

Checkout Wiki Page for more in depth example uses

Contributing

1. Fork this repository (if applicable).
2. Create a feature branch.
3. Submit a pull request describing your changes.

Please add tests and documentation for any new features.

License

This project is available under [MIT] License. Refer to the LICENSE file for more details.