config

Documentation

Index

• Constants
• Variables
• type ChatConfig
• type ChatProvider
• type CoquiConfig
• type DBConfig
• type DBDriver
• type DiffusionConfig
• type DiffusionProvider
• type DiscordConfig
• type ElevenLabsConfig
• type GPT4AllConfig
• type GoogleConfig
• type HTTPConfig
• type ImagePurpose
• type LLMConfig
• type LLMProvider
• type MiscConfig
• type ModelPurpose
• type OpenAIConfig
• type OpenAIConfigImageSize
• type OpenAIConfigModel
• type ReactConfig
• type STTConfig
• type STTProvider
• type SlackConfig
• type TTSConfig
• type TTSProvider
• type TelegramConfig
• type TimeoutsConfig
• type WhisperCppConfig

Constants

const (
	Completion    ModelPurpose = "completion"
	Transcription ModelPurpose = "transcription"
	Moderation    ModelPurpose = "moderation"
	Summarization ModelPurpose = "summarization"

	ImageGeneration ImagePurpose = "image_generation"
	ImageEdit       ImagePurpose = "image_edit"
	ImageVariation  ImagePurpose = "image_variation"
)

Variables

var Chat = &ChatConfig{
	Provider: ChatProvider(envOrDefaultWithOptions("CHLOE_CHAT_PROVIDER", string(OpenAIChat),
		[]string{string(OpenAIChat), string(GPT4AllChat)})),
}

var Coqui = &CoquiConfig{
	TTSVoiceID: envOrDefault("CHLOE_TTS_COQUI_VOICE_ID", "default"),
	TTSSpeed:   envOrDefaultFloat64("CHLOE_TTS_COQUI_SPEED", 1),
	TTSModel: envOrDefaultWithOptions("CHLOE_TTS_COQUI_MODEL", "xtts",
		[]string{"coqui_v1", "xtts"}),
	APIKey: envOrDefault("CHLOE_TTS_COQUI_API_KEY", ""),
}

var DB = &DBConfig{
	Driver: DBDriver(envOrDefaultWithOptions("CHLOE_DB_DRIVER", string(SQLite),
		[]string{string(Postgres), string(MySQL), string(SQLite), string(SQLServer)})),
	DSN:     envOrDefault("CHLOE_DB_DSN", "chloe.db"),
	MaxIdle: envOrDefaultIntInRange("CHLOE_DB_MAX_IDLE", 2, 0, 100),
	MaxOpen: envOrDefaultIntInRange("CHLOE_DB_MAX_OPEN", 10, 1, 1000),
}

var Diffusion = &DiffusionConfig{
	Provider: DiffusionProvider(envOrDefaultWithOptions("CHLOE_DIFFUSION_PROVIDER", string(OpenAIDiffusion),
		[]string{string(OpenAIDiffusion)})),
}

var Discord = &DiscordConfig{
	Token:                      envOrDefault("CHLOE_DISCORD_TOKEN", ""),
	ImageCount:                 envOrDefaultIntInRange("CHLOE_DISCORD_IMAGE_COUNT", 4, 1, 10),
	OnlyMention:                envOrDefaultBool("CHLOE_DISCORD_ONLY_MENTION", true),
	RandomStatusUpdateInterval: envOrDefaultDuration("CHLOE_DISCORD_RANDOM_STATUS_UPDATE_INTERVAL", 20*time.Second),
	StreamMessages:             envOrDefaultBool("CHLOE_DISCORD_STREAM_MESSAGES", false),
	StreamFlushInterval:        envOrDefaultDuration("CHLOE_DISCORD_STREAM_FLUSH_INTERVAL", 500*time.Millisecond),
	SendProcessingMessage:      envOrDefaultBool("CHLOE_DISCORD_SEND_PROCESSING_MESSAGE", false),
	ProcessingMessage:          envOrDefault("CHLOE_DISCORD_PROCESSING_MESSAGE", "↻ Processing..."),
	MaxMessageLength:           envOrDefaultIntInRange("CHLOE_DISCORD_MAX_MESSAGE_LENGTH", 2000, 1, 2000),
}

var ElevenLabs = &ElevenLabsConfig{
	TTSLanguageCode:    envOrDefault("CHLOE_TTS_ELEVENLABS_LANGUAGE_CODE", "eleven_multilingual_v2"),
	TTSVoiceName:       envOrDefault("CHLOE_TTS_ELEVENLABS_VOICE_NAME", "default"),
	TTSStability:       envOrDefaultFloat32InRange("CHLOE_TTS_ELEVENLABS_STABILITY", 60, 0, 100),
	TTSSimilarityBoost: envOrDefaultFloat32InRange("CHLOE_TTS_ELEVENLABS_SIMILARITY_BOOST", 90, 0, 100),
	APIKey:             envOrDefault("CHLOE_TTS_ELEVENLABS_API_KEY", ""),
}

var GPT4All = &GPT4AllConfig{
	Endpoint: envOrDefault("CHLOE_GPT4ALL_ENDPOINT", "http://localhost:4891/v1"),
	DefaultModel: envOrDefaultWithOptions("CHLOE_GPT4ALL_MODEL", "gpt-3.5-turbo",
		[]string{
			"mpt-7b-chat",
			"gpt-3.5-turbo",
			"gpt-4",
			"gpt4all-j-v1.3-groovy",
		}),
}

var Google = &GoogleConfig{
	TTSLanguageCode: envOrDefault("CHLOE_TTS_GOOGLE_LANGUAGE_CODE", "en-US"),
	TTSVoiceName:    envOrDefault("CHLOE_TTS_GOOGLE_VOICE_NAME", "en-US-Wavenet-F"),
	TTSEncoding:     envOrDefaultGCPTTSEncoding("CHLOE_TTS_GOOGLE_AUDIO_ENCONDING", texttospeechpb.AudioEncoding_MP3),
	TTSSpeakingRate: envOrDefaultFloat64InRange("CHLOE_TTS_GOOGLE_SPEAKING_RATE", 1, 0.25, 4),
	TTSPitch:        envOrDefaultFloat64InRange("CHLOE_TTS_GOOGLE_PITCH", 0, -20, 20),
	TTSVolumeGain:   envOrDefaultFloat64InRange("CHLOE_TTS_GOOGLE_VOLUME_GAIN", 0, -96, 16),
}

var HTTP = &HTTPConfig{
	Host: envOrDefault("CHLOE_HTTP_HOST", "0.0.0.0"),
	Port: envOrDefaultIntInRange("CHLOE_HTTP_PORT", 8080, 1, 65535),
}

var LLM = &LLMConfig{
	Provider: LLMProvider(envOrDefaultWithOptions("CHLOE_LLM_PROVIDER", string(OpenAIChat),
		[]string{string(OpenAIChat)})),
}

var Misc = &MiscConfig{
	TempDir:              envOrDefault("CHLOE_TEMP_DIR", filepath.Join(os.TempDir(), "chloe")),
	CostTrackingInterval: envOrDefaultDuration("CHLOE_COST_TRACKING_INTERVAL", 5*time.Minute),
	WorkspaceDir: envOrDefault("CHLOE_WORKSPACE_DIR", filepath.Join(func() string {
		if wd, err := os.Getwd(); err == nil {
			return wd
		}
		return os.TempDir()
	}(), "..", "..", "workspace")),
}

var OpenAI = &OpenAIConfig{
	ModerateMessages:  envOrDefaultBool("CHLOE_ENABLE_MESSAGE_MODERATION", true),
	SummarizeMessages: envOrDefaultBool("CHLOE_ENABLE_MESSAGE_SUMMARIZATION", true),

	MinReplyTokens: envOrDefaultInt("CHLOE_MIN_REPLY_TOKENS", 500),

	DefaultModel: OpenAIConfigModel{
		Completion:    envOrDefault("CHLOE_MODEL_COMPLETION", "gpt-3.5-turbo"),
		Transcription: envOrDefault("CHLOE_MODEL_TRANSCRIPTION", "whisper-1"),
		Moderation:    envOrDefault("CHLOE_MODEL_MODERATION", "text-moderation-latest"),
		Summarization: envOrDefault("CHLOE_MODEL_SUMMARIZATION", "gpt-3.5-turbo"),
	},

	DefaultSize: OpenAIConfigImageSize{
		ImageGeneration: envOrDefaultImageSize("CHLOE_IMAGE_GENERATION_SIZE", "1024x1024"),
		ImageEdit:       envOrDefaultImageSize("CHLOE_IMAGE_EDIT_SIZE", "1024x1024"),
		ImageVariation:  envOrDefaultImageSize("CHLOE_IMAGE_VARIATION_SIZE", "1024x1024"),
	},

	APIKey: envOrDefault("OPENAI_API_KEY", ""),

	MessagesToKeepFullContent: envOrDefaultInt("CHLOE_MESSAGES_TO_KEEP_FULL_CONTENT", 4),
	UseAzure:                  envOrDefaultBool("CHLOE_USE_AZURE", false),
	AzureAPIVersion:           envOrDefault("CHLOE_AZURE_API_VERSION", "2023-03-15-preview"),
	AzureBaseURL:              envOrDefault("CHLOE_AZURE_BASE_URL", ""),
	AzureEngine:               envOrDefault("CHLOE_AZURE_ENGINE", ""),
	UseFunctions:              envOrDefaultBool("CHLOE_USE_FUNCTIONS", true),
}

var React = &ReactConfig{
	ImproveImagePrompts:      envOrDefaultBool("CHLOE_REACT_IMPROVE_IMAGE_PROMPTS", false),
	GoogleMaxResults:         envOrDefaultIntInRange("CHLOE_REACT_GOOGLE_MAX_RESULTS", 4, 1, 10),
	GoogleCustomSearchAPIKey: envOrDefault("CHLOE_REACT_GOOGLE_CUSTOM_SEARCH_API_KEY", ""),
	GoogleCustomSearchID:     envOrDefault("CHLOE_REACT_GOOGLE_CUSTOM_SEARCH_ID", ""),
	WikipediaMaxResults:      envOrDefaultInt("CHLOE_REACT_WIKIPEDIA_MAX_RESULTS", 3),
	NewsAPIMaxResults:        envOrDefaultInt("CHLOE_REACT_NEWSAPI_MAX_RESULTS", 5),
	NewsSource: envOrDefaultWithOptions("CHLOE_REACT_NEWS_SOURCE", "openai",
		[]string{"openai", "newsapi"}),
	NewsAPIToken: envOrDefault("CHLOE_REACT_NEWSAPI_TOKEN", ""),
	NewsAPISortStrategy: envOrDefaultWithOptions("CHLOE_REACT_NEWSAPI_SORT_STRATEGY", "relevancy",
		[]string{"relevancy", "popularity", "publishedAt"}),
	UseAria2:             envOrDefaultBool("CHLOE_REACT_USE_ARIA2", true),
	FileWorkspace:        envOrDefault("CHLOE_REACT_FILE_WORKSPACE", filepath.Join(Misc.WorkspaceDir, "files")),
	OpenWeatherMapAPIKey: envOrDefault("CHLOE_REACT_OPENWEATHERMAP_API_KEY", ""),
}

var STT = &STTConfig{
	Provider: STTProvider(envOrDefaultWithOptions("CHLOE_STT_PROVIDER", string(WhisperCppSTT),
		[]string{string(WhisperCppSTT), string(OpenAISTT)})),
}

var Slack = &SlackConfig{
	Token:                 envOrDefault("CHLOE_SLACK_TOKEN", ""),
	AppLevelToken:         envOrDefault("CHLOE_SLACK_APP_LEVEL_TOKEN", ""),
	ImageCount:            envOrDefaultIntInRange("CHLOE_SLACK_IMAGE_COUNT", 4, 1, 10),
	OnlyMention:           envOrDefaultBool("CHLOE_SLACK_ONLY_MENTION", true),
	StreamMessages:        envOrDefaultBool("CHLOE_SLACK_STREAM_MESSAGES", true),
	StreamFlushInterval:   envOrDefaultDuration("CHLOE_SLACK_STREAM_FLUSH_INTERVAL", 500*time.Millisecond),
	SendProcessingMessage: envOrDefaultBool("CHLOE_SLACK_SEND_PROCESSING_MESSAGE", false),
	ProcessingMessage:     envOrDefault("CHLOE_SLACK_PROCESSING_MESSAGE", "↻ Processing..."),
	MaxMessageLength:      envOrDefaultIntInRange("CHLOE_SLACK_MAX_MESSAGE_LENGTH", 40000, 1, 40000),
}

var TTS = &TTSConfig{
	Provider: TTSProvider(envOrDefaultWithOptions("CHLOE_TTS_PROVIDER", string(GoogleTTS),
		[]string{string(GoogleTTS), string(ElevenLabsTTS), string(CoquiTTS)})),
}

var Telegram = &TelegramConfig{
	Token:                 envOrDefault("CHLOE_TELEGRAM_TOKEN", ""),
	ImageCount:            envOrDefaultIntInRange("CHLOE_TELEGRAM_IMAGE_COUNT", 4, 1, 10),
	StreamMessages:        envOrDefaultBool("CHLOE_TELEGRAM_STREAM_MESSAGES", false),
	StreamFlushInterval:   envOrDefaultDuration("CHLOE_TELEGRAM_STREAM_FLUSH_INTERVAL", 500*time.Millisecond),
	SendProcessingMessage: envOrDefaultBool("CHLOE_TELEGRAM_SEND_PROCESSING_MESSAGE", false),
	ProcessingMessage:     envOrDefault("CHLOE_TELEGRAM_PROCESSING_MESSAGE", "↻ Processing..."),
	MaxMessageLength:      envOrDefaultIntInRange("CHLOE_TELEGRAM_MAX_MESSAGE_LENGTH", 4096, 1, 4096),
}

var Timeouts = &TimeoutsConfig{
	Completion:      envOrDefaultDuration("CHLOE_TIMEOUT_COMPLETION", 60*time.Second),
	Transcription:   envOrDefaultDuration("CHLOE_TIMEOUT_TRANSCRIPTION", 120*time.Second),
	Moderation:      envOrDefaultDuration("CHLOE_TIMEOUT_MODERATION", 60*time.Second),
	ImageGeneration: envOrDefaultDuration("CHLOE_TIMEOUT_IMAGE_GENERATION", 120*time.Second),
	ImageEdit:       envOrDefaultDuration("CHLOE_TIMEOUT_IMAGE_EDIT", 120*time.Second),
	ImageVariation:  envOrDefaultDuration("CHLOE_TIMEOUT_IMAGE_VARIATION", 120*time.Second),
	TTS:             envOrDefaultDuration("CHLOE_TIMEOUT_TTS", 60*time.Second),
	SlownessWarning: envOrDefaultDuration("CHLOE_TIMEOUT_SLOWNESS_WARNING", 5*time.Second),
}

var WhisperCpp = &WhisperCppConfig{
	Model: envOrDefaultWithOptions("CHLOE_STT_WHISPERCPP_MODEL", "large",
		[]string{"base", "tiny", "small", "medium", "large"}),
	Language: envOrDefaultWithOptions("CHLOE_STT_WHISPERCPP_LANGUAGE", "pt",
		[]string{"en", "pt"}),
}

Types

type ChatConfig

type ChatConfig struct {
	Provider ChatProvider
}

type ChatProvider

type ChatProvider string

const (
	OpenAIChat  ChatProvider = "openai"
	GPT4AllChat ChatProvider = "gpt4all"
)

type CoquiConfig

type CoquiConfig struct {
	TTSVoiceID string
	APIKey     string
	TTSSpeed   float64
	TTSModel   string
}

type DBConfig

type DBConfig struct {
	Driver  DBDriver
	DSN     string
	MaxIdle int
	MaxOpen int
}

type DBDriver

type DBDriver string

const (
	Postgres  DBDriver = "postgres"
	MySQL     DBDriver = "mysql"
	SQLite    DBDriver = "sqlite"
	SQLServer DBDriver = "sqlserver"
)

type DiffusionConfig

type DiffusionConfig struct {
	Provider DiffusionProvider
}

type DiffusionProvider

type DiffusionProvider string

const (
	OpenAIDiffusion DiffusionProvider = "openai"
)

type DiscordConfig

type DiscordConfig struct {
	Token                      string
	ImageCount                 int
	OnlyMention                bool
	RandomStatusUpdateInterval time.Duration
	StreamMessages             bool
	StreamFlushInterval        time.Duration
	SendProcessingMessage      bool
	ProcessingMessage          string
	MaxMessageLength           int
}

type ElevenLabsConfig

type ElevenLabsConfig struct {
	TTSLanguageCode    string
	TTSVoiceName       string
	TTSStability       float32
	TTSSimilarityBoost float32
	APIKey             string
}

type GPT4AllConfig

type GPT4AllConfig struct {
	Endpoint     string `json:"endpoint"`
	DefaultModel string `json:"default_model"`
}

type GoogleConfig

type GoogleConfig struct {
	TTSLanguageCode string
	TTSVoiceName    string
	TTSEncoding     texttospeechpb.AudioEncoding
	TTSSpeakingRate float64
	TTSPitch        float64
	TTSVolumeGain   float64
}

type HTTPConfig

type HTTPConfig struct {
	Host string
	Port int
}

type ImagePurpose

type ImagePurpose string

type LLMConfig

type LLMConfig struct {
	Provider LLMProvider
}

type LLMProvider

type LLMProvider string

const (
	OpenAILLM LLMProvider = "openai"
)

type MiscConfig

type MiscConfig struct {
	TempDir              string
	CostTrackingInterval time.Duration
	WorkspaceDir         string
}

type ModelPurpose

type ModelPurpose string

type OpenAIConfig

type OpenAIConfig struct {
	MinReplyTokens            int
	DefaultModel              OpenAIConfigModel
	DefaultSize               OpenAIConfigImageSize
	APIKey                    string
	MessagesToKeepFullContent int
	ModerateMessages          bool
	SummarizeMessages         bool
	UseAzure                  bool
	AzureAPIVersion           string
	AzureBaseURL              string
	AzureEngine               string
	UseFunctions              bool
}

type OpenAIConfigImageSize

type OpenAIConfigImageSize struct {
	ImageGeneration string
	ImageEdit       string
	ImageVariation  string
}

type OpenAIConfigModel

type OpenAIConfigModel struct {
	Completion    string
	Transcription string
	Moderation    string
	Summarization string
}

type ReactConfig

type ReactConfig struct {
	ImproveImagePrompts      bool
	GoogleMaxResults         int
	GoogleCustomSearchAPIKey string
	GoogleCustomSearchID     string
	WikipediaMaxResults      int
	NewsSource               string
	NewsAPIToken             string
	NewsAPIMaxResults        int
	NewsAPISortStrategy      string
	UseAria2                 bool
	FileWorkspace            string
	OpenWeatherMapAPIKey     string
}

type STTConfig

type STTConfig struct {
	Provider STTProvider
}

type STTProvider

type STTProvider string

const (
	WhisperCppSTT STTProvider = "whispercpp"
	OpenAISTT     STTProvider = "openai"
)

type SlackConfig

type SlackConfig struct {
	Token                 string
	AppLevelToken         string
	ImageCount            int
	OnlyMention           bool
	StreamMessages        bool
	StreamFlushInterval   time.Duration
	SendProcessingMessage bool
	ProcessingMessage     string
	MaxMessageLength      int
}

type TTSConfig

type TTSConfig struct {
	Provider TTSProvider
}

type TTSProvider

type TTSProvider string

const (
	GoogleTTS     TTSProvider = "google"
	ElevenLabsTTS TTSProvider = "elevenlabs"
	CoquiTTS      TTSProvider = "coqui"
)

type TelegramConfig

type TelegramConfig struct {
	Token                 string
	ImageCount            int
	StreamMessages        bool
	StreamFlushInterval   time.Duration
	SendProcessingMessage bool
	ProcessingMessage     string
	MaxMessageLength      int
}

type TimeoutsConfig

type TimeoutsConfig struct {
	Completion      time.Duration
	Transcription   time.Duration
	Moderation      time.Duration
	ImageGeneration time.Duration
	ImageEdit       time.Duration
	ImageVariation  time.Duration
	TTS             time.Duration
	SlownessWarning time.Duration
}

type WhisperCppConfig

type WhisperCppConfig struct {
	Model    string
	Language string
}