Contributing to Agent-Boot

August 10, 2025 · View on GitHub

Thank you for your interest in contributing to Agent-Boot! This document provides guidelines and information for contributors.

🚀 Getting Started

Prerequisites

Go 1.24+ installed
Git
Protocol Buffers compiler (for schema changes)

Development Setup

Fork and Clone

git clone https://github.com/your-username/agent-boot.git
cd agent-boot

Install Dependencies
```
go mod download
```
Run Tests
```
go test ./...
```
Generate Protocol Buffers (if needed)
```
cd proto
./build.sh
```

🛠️ Development Guidelines

Code Style

Follow standard Go conventions
Use gofmt for formatting
Add comments for exported functions and types
Keep functions focused and small

Testing

Write tests for new functionality
Maintain or improve test coverage
Use table-driven tests where appropriate
Include benchmarks for performance-critical code

Example test structure:

func TestFeatureName(t *testing.T) {
    tests := []struct {
        name     string
        input    InputType
        expected OutputType
        wantErr  bool
    }{
        // test cases
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // test implementation
        })
    }
}

Documentation

Update README.md for user-facing changes
Add package-level documentation
Include examples in doc comments
Update API documentation

📋 Types of Contributions

🐛 Bug Reports

When reporting bugs, please include:

Go version and OS
Minimal reproduction case
Expected vs actual behavior
Relevant logs or error messages

✨ Feature Requests

For feature requests:

Describe the use case
Explain why it would be valuable
Consider backwards compatibility
Provide implementation ideas if possible

🔧 Code Contributions

We welcome:

Bug fixes
New LLM provider support
Tool implementations
Performance improvements
Documentation improvements

Areas Looking for Contributions

LLM Providers: OpenAI, Google Gemini, AWS Bedrock
Tools: File operations, API calls, data processing
Examples: Real-world use cases and tutorials
Performance: Optimization and benchmarking
Documentation: Tutorials, guides, API docs

🔄 Pull Request Process

Create an Issue (for large changes)
- Discuss the change before implementing
- Get feedback on approach

Create a Branch

git checkout -b feature/descriptive-name

Make Changes
- Follow coding guidelines
- Add tests
- Update documentation

Test Your Changes

go test ./...
go test ./... -race
go test ./... -bench=.

Commit
```
git commit -m "feat: add new LLM provider support"
```
Use conventional commit format:
- feat: new features
- fix: bug fixes
- docs: documentation changes
- refactor: code refactoring
- test: adding tests
- perf: performance improvements

Push and Create PR

git push origin feature/descriptive-name

PR Review
- Address review comments
- Update tests if needed
- Ensure CI passes

🏗️ Architecture Guidelines

Adding New LLM Providers

Implement the LLMClient interface:

type NewProviderClient struct {
    // provider-specific fields
}

func (c *NewProviderClient) GenerateInference(...) error {
    // implementation
}

func (c *NewProviderClient) GenerateInferenceWithTools(...) error {
    // implementation
}

func (c *NewProviderClient) Capabilities() llm.Capability {
    // return supported capabilities
}

func (c *NewProviderClient) GetModel() string {
    // return model name
}

Add tests in llm/new_provider_test.go
Update documentation and examples

Adding New Tools

Use the MCP tool builder:

tool := agent.NewMCPTool("tool-name", "description").
    StringParam("param", "description", required).
    WithHandler(handlerFunc).
    Build()

Implement handler with proper error handling
Add comprehensive tests
Document usage examples

Schema Changes

Update proto/agent.proto
Run ./proto/build.sh to regenerate
Update code using the schema
Test backwards compatibility

🧪 Testing Guidelines

Test Structure

agent/
├── agent_test.go              # Unit tests for agent.go
├── agent_builder_test.go      # Unit tests for builder
├── execute_turn_based_test.go # Integration tests
└── integration_test.go        # End-to-end tests