Go Examples

These examples use Go's standard net/http and encoding/json packages.

Setup

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
)

const baseURL = "https://api.modelgraph.ai/api/v1"

List all providers

func listProviders() error {
	resp, err := http.Get(baseURL + "/providers")
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	var result struct {
		Providers []struct {
			Slug       string `json:"slug"`
			Name       string `json:"name"`
			ModelCount int    `json:"model_count"`
		} `json:"providers"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return fmt.Errorf("decode failed: %w", err)
	}

	for _, p := range result.Providers {
		fmt.Printf("%s: %d models\n", p.Name, p.ModelCount)
	}

	return nil
}

Resolve a model string

type ResolveResponse struct {
	MatchedModel struct {
		Slug        string `json:"slug"`
		DisplayName string `json:"display_name"`
		Status      string `json:"status"`
		Family      string `json:"family"`
	} `json:"matched_model"`
	MatchedAlias struct {
		Alias  string `json:"alias"`
		Source string `json:"source"`
	} `json:"matched_alias"`
	Confidence   float64 `json:"confidence"`
	IsLatest     bool    `json:"is_latest"`
	Upgrade      *struct {
		Slug        string `json:"slug"`
		DisplayName string `json:"display_name"`
		Status      string `json:"status"`
	} `json:"upgrade"`
	UpgradeAlias *struct {
		Alias  string `json:"alias"`
		Source string `json:"source"`
	} `json:"upgrade_alias"`
}

func resolveModel(modelString string) (*ResolveResponse, error) {
	u := fmt.Sprintf("%s/resolve?q=%s", baseURL, url.QueryEscape(modelString))
	resp, err := http.Get(u)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNotFound {
		return nil, fmt.Errorf("model not found: %s", modelString)
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("API error: status %d", resp.StatusCode)
	}

	var result ResolveResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, fmt.Errorf("decode failed: %w", err)
	}

	return &result, nil
}

Check a model for upgrades

func checkModel(modelString string) {
	result, err := resolveModel(modelString)
	if err != nil {
		fmt.Printf("  ? %s — %v\n", modelString, err)
		return
	}

	if result.IsLatest {
		fmt.Printf("  ✓ %s — up to date (%s)\n",
			modelString, result.MatchedModel.DisplayName)
	} else if result.UpgradeAlias != nil {
		fmt.Printf("  ⬆ %s → %s (%s)\n",
			modelString, result.UpgradeAlias.Alias, result.Upgrade.DisplayName)
	}
}

func main() {
	models := []string{
		"claude-3-sonnet-20240229",
		"gpt-4-0613",
		"anthropic.claude-3-5-sonnet-20241022-v2:0",
		"mistral-large-2402",
		"claude-sonnet-4-6",
	}

	fmt.Println("Checking model strings for upgrades...\n")
	for _, m := range models {
		checkModel(m)
	}
}

Search for models

func searchModels(query string) error {
	u := fmt.Sprintf("%s/search?q=%s", baseURL, url.QueryEscape(query))
	resp, err := http.Get(u)
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	var result struct {
		Results []struct {
			Slug        string `json:"slug"`
			DisplayName string `json:"display_name"`
			Provider    struct {
				Name string `json:"name"`
			} `json:"provider"`
			Score float64 `json:"score"`
		} `json:"results"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return fmt.Errorf("decode failed: %w", err)
	}

	for _, r := range result.Results {
		fmt.Printf("%s (%s) — score: %.2f\n", r.DisplayName, r.Provider.Name, r.Score)
	}

	return nil
}

List deprecated models

func listDeprecatedModels(provider string) error {
	u := fmt.Sprintf("%s/models?provider=%s&status=deprecated", baseURL, provider)
	resp, err := http.Get(u)
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	var result struct {
		Models []struct {
			Slug            string  `json:"slug"`
			DisplayName     string  `json:"display_name"`
			DeprecationDate *string `json:"deprecation_date"`
			SunsetDate      *string `json:"sunset_date"`
		} `json:"models"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return fmt.Errorf("decode failed: %w", err)
	}

	fmt.Printf("Deprecated %s models:\n", provider)
	for _, m := range result.Models {
		fmt.Printf("  %s", m.DisplayName)
		if m.DeprecationDate != nil {
			fmt.Printf(" (deprecated: %s)", *m.DeprecationDate)
		}
		if m.SunsetDate != nil {
			fmt.Printf(" (sunset: %s)", *m.SunsetDate)
		}
		fmt.Println()
	}

	return nil
}