Bond

Bond is a Go package for building and managing AI assistant tools and agents, with a focus on extensibility and ease of use.

Overview

Bond provides a flexible framework for:

1. Creating custom tools for AI assistants
2. Managing specialized agents for different tasks
3. Connecting with AI providers like Claude and OpenAI
4. Orchestrating complex multi-step reasoning workflows

Packages

• models: Core interfaces and types used throughout the project
• tools: Framework for creating, managing, and executing tools
• agent: Framework for building specialized agents for different capabilities
• providers: Integration with AI providers (Claude, OpenAI)
• reasoning: Multi-step reasoning with state management and workflow orchestration

Installation

go get github.com/devOpifex/bond

Key Concepts

Messages and Roles

Bond uses a structured approach to messages with different roles:

// Create a message with a specific role
message := models.Message{
    Role:    models.RoleUser,     // Use predefined role constants
    Content: "Your message here",
}

Available role constants:

• models.RoleUser - For messages from the user
• models.RoleAssistant - For messages from the AI assistant
• models.RoleSystem - For system instructions (Claude uses a separate field)
• models.RoleFunction - For function/tool responses

System Prompts

You can set a system prompt to guide the AI's behavior across all messages:

// Set a system prompt to guide the AI's behavior
provider.SetSystemPrompt("You are a helpful assistant that specializes in data analysis.")

The system prompt provides context and instructions that persist across the conversation.

Basic Example

Here's a simple example showing how to create a custom tool, register it with Claude, and use it:

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devOpifex/bond/models"
	"github.com/devOpifex/bond/providers/claude"
	"github.com/devOpifex/bond/tools"
)

func main() {
	// Create a Claude provider
	provider := claude.NewClient(os.Getenv("ANTHROPIC_API_KEY"))

	// Configure provider
	provider.SetModel("claude-3-sonnet-20240229")
	provider.SetMaxTokens(1000)

	// Create a weather tool
	weatherTool := tools.NewTool(
		"get_weather",
		"Get current weather information for a location",
		models.InputSchema{
			Type: "object",
			Properties: map[string]models.Property{
				"location": {
					Type:        "string",
					Description: "The city and state or city/country (e.g., 'San Francisco, CA')",
				},
			},
			Required: []string{"location"},
		},
		func(params map[string]interface{}) (string, error) {
			location, _ := params["location"].(string)
			// In a real implementation, you would call a weather API here
			return fmt.Sprintf("The weather in %s is 10°C and raining as usual", location), nil
		},
	)

	// Register the tool with the provider
	provider.RegisterTool(weatherTool)

	// Set a system prompt to guide the AI's behavior
	provider.SetSystemPrompt("You are a weather assistant. Always be concise and factual.")

	// Send a message that will use the tool
	ctx := context.Background()
	response, err := provider.SendMessageWithTools(
		ctx,
		models.Message{
			Role:    models.RoleUser,
			Content: "What's the weather like in Brussels, Belgium?",
		},
	)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Claude's response: %s\n", response)
}

Documentation

• GitHub Repository