Configure Your Own LLM Provider

api/integration-api/internal/caller/<provider>/
├── llm.go      # LargeLanguageCaller implementation
└── <provider>.go  # Optional — client initialisation helpers

mkdir api/integration-api/internal/caller/myprovider

// api/integration-api/internal/caller/myprovider/llm.go
package myprovider

type myProviderCaller struct {
    logger *zap.SugaredLogger
}

func NewMyProviderCaller(logger *zap.SugaredLogger) *myProviderCaller {
    return &myProviderCaller{logger: logger}
}

// GetChatCompletion returns a complete (non-streaming) response.
func (c *myProviderCaller) GetChatCompletion(
    ctx         context.Context,
    messages    []caller.ChatMessage,
    opts        caller.ChatCompletionOptions,
    credentials map[string]interface{},
) (*caller.ChatCompletion, error) {
    // Read credentials from the vault map
    apiKey := credentials["key"].(string)

    // Read model parameters
    modelName, _ := opts.ModelParameter["model.name"].(string)
    temperature, _ := opts.ModelParameter["model.temperature"].(float64)

    // Call your provider API
    // Return &caller.ChatCompletion{Content: "...", ...}
    _ = apiKey
    _ = modelName
    _ = temperature
    return nil, nil
}

// StreamChatCompletion streams tokens via callbacks.
func (c *myProviderCaller) StreamChatCompletion(
    ctx         context.Context,
    messages    []caller.ChatMessage,
    opts        caller.ChatCompletionOptions,
    credentials map[string]interface{},
    onStream    func(token string),          // call for each token
    onMetrics   func(caller.LLMMetrics),     // call once at end with token counts
    onError     func(err error),             // call on error
) error {
    apiKey := credentials["key"].(string)
    modelName, _ := opts.ModelParameter["model.name"].(string)

    // Stream tokens from your provider
    // For each token: onStream(token)
    // On completion: onMetrics(metrics)
    // On error: onError(err)
    _ = apiKey
    _ = modelName
    return nil
}

func GetLargeLanguageCaller(provider string, logger *zap.SugaredLogger) (LargeLanguageCaller, error) {
    switch provider {
    case "openai":
        return openai.NewOpenAICaller(logger), nil
    // ... existing cases ...
    case "my-provider":
        return myprovider.NewMyProviderCaller(logger), nil
    default:
        return nil, fmt.Errorf("unsupported LLM provider: %s", provider)
    }
}

make rebuild-integration
make logs-integration