diff --git a/CHANGELOG.md b/CHANGELOG.md index ee67ecd0b..93151adcc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,114 @@ All notable changes to GBrain will be documented in this file. +## [0.32.0] - 2026-05-10 + +**5 new embedding providers + the discoverability fix that closes the 17-PR dupe cluster.** +**`gbrain providers list` now shows 14 recipes; `gbrain doctor` tells you which alternatives are already wired.** + +A triage of 197 open issues + 289 open PRs surfaced a 17-PR cluster of community embedding-provider PRs filed within ~3 weeks (Ollama, Gemini, Voyage, Azure, MiniMax, Copilot, llama-server, Vertex, DashScope, Zhipu, etc.). Most were dupes of work already in master — gbrain has shipped a comprehensive AI SDK gateway + recipe pattern since v0.14, with 9 providers built in. Users just didn't know. + +v0.32.0 ships the missing recipes that aren't covered by the existing pattern, plus a documentation pass + doctor advisory + improved error hints that close the discoverability gap. Codex outside-voice review during plan-eng-review caught the discoverability framing — without it, the wave would have shipped 8 recipes plus an OAuth subsystem instead of the focused 5-recipe + docs delivery. + +### The numbers that matter + +``` +gbrain providers list → v0.31.1: 9 providers → v0.32.0: 14 providers +gbrain doctor → v0.31.1: 1 advisory → v0.32.0: 2 advisories (+ alternative_providers) +``` + +5 new recipes: + +| Recipe | Auth | Default dims | Notes | +|---|---|---|---| +| `azure-openai` | `AZURE_OPENAI_API_KEY` + `AZURE_OPENAI_ENDPOINT` + `AZURE_OPENAI_DEPLOYMENT` | 1536 | First recipe with `api-key:` custom header (not Bearer); first with templated URL + `?api-version=` query injection | +| `minimax` | `MINIMAX_API_KEY` | 1536 | China-region; embo-01 model; type='db' asymmetric retrieval field plumbed via dims.ts | +| `dashscope` | `DASHSCOPE_API_KEY` | 1024 | Alibaba; international endpoint default; CJK-aware batching (chars_per_token=2) | +| `zhipu` | `ZHIPUAI_API_KEY` | 1024 | BigModel; embedding-3 with Matryoshka up to 2048 (HNSW falls back to exact-scan past 2000 dims) | +| `llama-server` | (none) | user-set | llama.cpp's `llama-server --embeddings`; user_provided_models recipe | + +### What this means for new users + +`gbrain init` keeps OpenAI as the zero-config default. Users with API keys for any of the other 13 providers see them surfaced via `gbrain doctor` ("Detected 2 alternative embedding providers ready to use: voyage, dashscope. Run `gbrain providers list` to switch."). Users on Azure tenancies, China-region, or local-only setups have first-class recipes instead of "find a workaround." Users with provider needs gbrain doesn't ship can route through LiteLLM proxy (the universal escape hatch) without writing custom code. + +For agents: every recipe is registered in the same `listRecipes()` registry, so `gbrain providers list/test/env/explain` automatically picks up new recipes without code changes. The recipe contract test (`test/ai/recipes-contract.test.ts`) keeps the registry honest. + +### To take advantage of v0.32.0 + +`gbrain upgrade` should do this automatically. If it didn't: + +1. **Confirm the new recipes show:** + ```bash + gbrain providers list + ``` + Should show 14 entries including `azure-openai`, `minimax`, `dashscope`, `zhipu`, `llama-server`. + +2. **Try the doctor advisory:** + ```bash + gbrain doctor + ``` + Look for the `alternative_providers` row. If env vars for unconfigured providers are present, it'll name them. + +3. **Read the new docs** at [`docs/integrations/embedding-providers.md`](docs/integrations/embedding-providers.md) — capability matrix, decision tree, per-recipe setup, "my provider isn't listed" path. + +4. **No breaking changes**: the existing 9 recipes (openai, anthropic, google, deepseek, groq, ollama, litellm-proxy, together, voyage) keep working unchanged. The internal auth refactor (D12=A unified resolveAuth seam) is pinned by `test/ai/recipes-existing-regression.test.ts` so the next refactor can't silently break them. + +5. **If anything breaks**, file an issue at https://github.com/garrytan/gbrain/issues with `gbrain doctor` output. The only behavior change for existing recipes: Ollama expansion + chat now read `OLLAMA_API_KEY` when set (embedding already did; the unification aligns all three touchpoints). + +### Itemized changes + +#### Architectural foundations + +- **Recipe.resolveAuth(env) seam (D12=A)**: unified the openai-compatible auth path, which was duplicated 3 times across `instantiateEmbedding`, `instantiateExpansion`, `instantiateChat` with subtle drift. Default impl (used by all existing recipes unchanged) returns `{headerName: 'Authorization', token: 'Bearer '}`. Recipes deviating override; Azure is the first. +- **Recipe.resolveOpenAICompatConfig(env) seam**: env-templated baseURL + optional fetch wrapper for recipes whose URL shape doesn't fit a static `base_url_default`. Azure uses both seams. +- **Recipe.probe() seam (D13=A)**: recipe-owned readiness check for local-server providers. Replaces the hardcoded `recipe.id === 'ollama'` special case in `runExplain()`. llama-server declares its own probe; future local providers self-register. +- **EmbeddingTouchpoint.user_provided_models?: true (D8=A)**: explicit signal for recipes that ship without a fixed model list (litellm, llama-server). Replaces the legacy `recipe.id === 'litellm'` hardcode in gateway.ts:223; refusal in `init.ts:resolveAIOptions` for shorthand `--model` with a setup hint pointing at the explicit form. +- **EmbeddingTouchpoint.no_batch_cap?: true**: silences the missing-max_batch_tokens startup warning for recipes with genuinely dynamic batch capacity (Ollama, LiteLLM proxy, llama-server). Pre-fix: 3 stderr warnings on every `configureGateway()` call. Post-fix: only `google` warns. + +#### Discoverability + +- New `docs/integrations/embedding-providers.md` (one-pager: capability table, decision tree, per-recipe setup, "my provider isn't listed" path to LiteLLM). +- README embedding-providers callout near the top of the install section. +- `gbrain doctor` adds an `alternative_providers` check that surfaces recipes whose env vars are already set but aren't the configured provider. +- `gbrain init --model litellm` (or any user_provided_models recipe) now refuses with a structured setup hint instead of throwing "no embedding models listed." + +#### Adjacent fixes + +- **#779 (alexandreroumieu-codeapprentice) reworked**: `EmbeddingTouchpoint.no_batch_cap?: true` opt-out for dynamic-cap recipes. +- **#121 (vinsew) reworked**: `~/.gbrain/config.json` API keys now propagate to the gateway env. Pre-fix, `openai_api_key` / `anthropic_api_key` config-file values were ignored (the gateway only saw `process.env`). Common bite: launchd-spawned daemons or agent subprocess tools without `~/.zshrc` propagation. Process env still wins on conflict. +- `loadConfig()` now merges `ANTHROPIC_API_KEY` env var into the file-config result (was silently dropped). +- IRON RULE regression test (`test/ai/recipes-existing-regression.test.ts`): pins that the v0.32 resolveAuth refactor preserves auth behavior for the existing 9 recipes. + +### Closed as superseded + +The following community PRs are closed because their work is now covered by the recipe system + LiteLLM proxy escape hatch + the recipes shipped in this wave: + +- #49, #58, #73, #100, #112, #134, #137, #150, #172, #178, #255, #327, #420, #482, #516, #780, #89 — pluggable embedding adapter / Ollama / Gemini / E5 / Azure-via-LiteLLM / etc. + +Each contributor identified a real gap; the patterns they prototyped converged on the recipe system that was shipped in v0.14. Thank you for the early signal. + +### Deferred to v0.32.x (with TODOS.md entries) + +- **#729 Vertex AI ADC** (lucha0404): proper ADC chain (metadata server, gcloud creds, service-account JSON) is a real product surface, not the single-source-JSON path the original PR proposed. +- **#691 GitHub Copilot** (tonyxu-io): outbound OAuth is a new product surface (login flow, browser/device flow, refresh, UX), not a sidecar recipe. Needs its own design pass. +- **#698 OpenAI Codex OAuth** (perlantir): same OAuth-product-surface argument; chat-only. +- **#765 Hunyuan PGLite + CJK keyword fallback** (313094319-sudo): the CJK PGLite branch is ~150 lines of new SQL + scoring logic that deserves its own focused PR rather than being folded into a 9-commit wave. +- **Interactive provider chooser in `gbrain init`**: the wizard piece of the discoverability lane. v0.32.0 ships the doctor advisory + cleaner refusal that close the 80% case; the full wizard is a v0.32.x follow-up. +- **Real-credentials per-recipe smoke fixtures**: opt-in CI matrix gated on API-key budget approval. + +### Contributors + +Reworked from / inspired by: +- @cacity (#148 MiniMax) +- @JamesJZhang (#459 Azure OpenAI) +- @Magicray1217 (#59 DashScope + Zhipu) +- @SiyaoZheng (#702 llama-server) +- @alexandreroumieu-codeapprentice (#779) +- @vinsew (#121) +- @100yenadmin / Eva (Voyage 4 Large 2048d HNSW policy, shipped earlier via 3004a87) + +Codex outside-voice review during plan-eng-review drove the scope reduction (D11=C) from 8 recipes + OAuth subsystem to 5 recipes + docs. + ## [0.31.1] - 2026-05-08 **Thin-client mode actually works now. `gbrain init --mcp-only` is no longer a half-built bridge.** diff --git a/README.md b/README.md index 07d424b80..0032f810a 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,8 @@ GBrain is those patterns, generalized. 34 skills. Install in 30 minutes. Your ag > **LLMs:** fetch [`llms.txt`](llms.txt) for the documentation map, or [`llms-full.txt`](llms-full.txt) for the same map with core docs inlined in one fetch. **Agents:** start with [`AGENTS.md`](AGENTS.md) (or [`CLAUDE.md`](CLAUDE.md) if you're Claude Code). +> **Embedding providers:** OpenAI is the default, but gbrain ships with **14 recipes** covering Voyage, Google Gemini, Azure OpenAI, MiniMax, Alibaba DashScope, Zhipu, Ollama (local), llama.cpp llama-server (local), LiteLLM proxy (universal), and 5 more. Run `gbrain providers list` to see them, or read [`docs/integrations/embedding-providers.md`](docs/integrations/embedding-providers.md) for setup, pricing, and a decision tree. `gbrain doctor` will surface alternative providers whose env vars you already have set. + ## Install ### On an agent platform (recommended) diff --git a/TODOS.md b/TODOS.md index 58a32d827..b2b4abe9a 100644 --- a/TODOS.md +++ b/TODOS.md @@ -1,5 +1,71 @@ # TODOS +## Embedding-provider follow-ups (v0.32.0) + +- [ ] **v0.32.x: Vertex AI ADC embedding provider (#729 originally).** lucha0404 + prototyped this with single-source-JSON via `GOOGLE_APPLICATION_CREDENTIALS`. + Real ADC is the full chain (metadata server, gcloud creds, service-account + JSON). The recipe needs to either use `@ai-sdk/google-vertex` (one new + dep, native fit) or implement the chain via Bun.crypto.subtle for RS256 + JWT signing (zero dep, ~150 lines + RS256 spike). Original Q3 chose + zero-dep; revisit the dep budget when scoping. + +- [ ] **v0.32.x: GitHub Copilot embeddings (#691 originally).** tonyxu-io + proposed adding Copilot's Metis embedding endpoint as a sidecar recipe. + Codex review caught that this is not a recipe-add — it's an outbound OAuth + product surface (login flow, browser/device flow, refresh, UX). Needs its + own design pass: where does the token live? `~/.gbrain/oauth/copilot.json` + mode 0600 was the v0.32 plan; revisit + write `gbrain auth login copilot`. + +- [ ] **v0.32.x: OpenAI Codex OAuth chat provider (#698 originally).** perlantir + proposed a chat-only provider that reuses ChatGPT subscription auth instead + of API keys. Same OAuth-product-surface argument as #691. Same shared + infra: `~/.gbrain/oauth/.json` + `gbrain auth login `. + Build alongside #691 in one OAuth-subsystem wave. + +- [ ] **v0.32.x: CJK PGLite keyword fallback (#765 extracted).** 313094319-sudo + hit a real gap: PGLite's FTS doesn't tokenize CJK well, so Chinese queries + return empty results even with proper embeddings. Their PR added a + hasCJK detection branch in `searchKeyword` that switches to LIKE-based + fuzzy matching with a custom scoring function. ~150 lines of new SQL + + scoring + tests. Worth its own focused PR rather than folded into the + v0.32 wave's adjacent-fix lane. Extract `extractSearchTokens`, + `normalizeSearchText`, `hasCJK` helpers + the CJK branch in + `pglite-engine.ts:searchKeyword`. Includes tests for romaji + Korean + Hangul + traditional/simplified Chinese. + +- [ ] **v0.32.x: interactive provider chooser in `gbrain init`.** The full + wizard piece of the v0.32 discoverability lane was deferred. Today + `gbrain init` (no flags, TTY) silently uses OpenAI default. Plan: hook + into `init.ts:resolveAIOptions`, when no `--model` AND TTY AND not + `--non-interactive`, call `runExplain([])` (non-JSON path) from + `providers.ts:233-350` to print the provider matrix, then prompt with + readline (mirror `supabaseWizard()` at `init.ts:108`). Suggest + recommended based on env detection. Refuse `user_provided_models` + shorthand (already done in v0.32.0). Tests: + `test/init-provider-wizard.test.ts` (TTY → prompt fires; non-TTY → + falls through; invalid choice → re-prompts). + +- [ ] **v0.32.x: real-credentials per-recipe smoke-test CI matrix.** Codex + finding #6 noted that unit tests via `__setEmbedTransportForTests` prove + routing but not contract correctness with the actual provider HTTP + shape. Provider APIs change quietly (Voyage encoding-format, MiniMax + type field, Azure header). One real-call per recipe per month catches + drift before users do; <$1/run estimated. Requires API-key budget + approval + repo secrets. + +- [ ] **v0.32.x: MiniMax asymmetric retrieval support.** v0.32 ships + `embo-01` with `type: 'db'` for both indexing and queries (symmetric + retrieval). True asymmetric needs a query/document signal threaded + through the embed seam. Worth it for MiniMax users who care about + retrieval quality on Chinese content; defer until users complain. + +- [ ] **v0.32.x: un-hardcode the multimodal dispatch at gateway.ts:583.** + Currently `recipe.id !== 'voyage'` is hardcoded — harmless until a + second multimodal recipe lands. Make it table-driven via + `Recipe.touchpoints.embedding.supports_multimodal` + + `multimodal_models`. ~10 lines + a contract test. + ## Thin-client mode follow-ups (v0.31.1, Issue #734) - [ ] **v0.31.x: routed-call timing telemetry.** `GBRAIN_TIMING=1` prints diff --git a/VERSION b/VERSION index f176c9441..9eb2aa3f1 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.31.1 +0.32.0 diff --git a/docs/integrations/embedding-providers.md b/docs/integrations/embedding-providers.md new file mode 100644 index 000000000..943728e96 --- /dev/null +++ b/docs/integrations/embedding-providers.md @@ -0,0 +1,130 @@ +# Embedding providers + +GBrain ships with 14 embedding-provider recipes covering OpenAI, the major hosted alternatives, three local options, and a universal escape hatch (LiteLLM proxy). Run `gbrain providers list` to see the live registry; `gbrain providers explain --json` emits a machine-readable matrix for agents. + +This page is the human-readable counterpart: capability per provider, env-var setup, dimensions, cost, and known constraints. + +## Quick start + +``` +gbrain providers list # see all providers +gbrain providers env # see required env vars +gbrain providers test --model openai:text-embedding-3-large # smoke-test +gbrain init --pglite --model voyage # use a non-default provider +``` + +## TL;DR table + +| Provider | env vars | default dims | cost ($/1M tokens) | local? | multimodal? | +|---|---|---|---|---|---| +| `openai` | `OPENAI_API_KEY` | 1536 | 0.13 | no | no | +| `voyage` | `VOYAGE_API_KEY` | 1024 | 0.18 | no | yes (`voyage-multimodal-3`) | +| `google` | `GOOGLE_GENERATIVE_AI_API_KEY` | 768 | 0.025 | no | no | +| `azure-openai` | `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_DEPLOYMENT` | 1536 | 0.13 | no | no | +| `minimax` | `MINIMAX_API_KEY` | 1536 | 0.07 | no | no | +| `dashscope` | `DASHSCOPE_API_KEY` | 1024 | varies | no | no | +| `zhipu` | `ZHIPUAI_API_KEY` | 1024 | varies | no | no | +| `ollama` | (none — runs locally) | 768 | 0 | yes | no | +| `llama-server` | (none — runs locally) | user-set | 0 | yes | no | +| `litellm` | `LITELLM_API_KEY` (optional) | user-set | varies | yes (proxy) | no | +| `together` | `TOGETHER_API_KEY` | 768 | varies | no | no | +| `anthropic` | (no embedding model — chat only) | — | — | — | — | +| `deepseek` | (no embedding model — chat only) | — | — | — | — | +| `groq` | (no embedding model — chat only) | — | — | — | — | + +## Decision tree + +- **Cost-sensitive, English-only**: Ollama (free, local) or Voyage (paid, best quality per dollar). +- **Quality-first**: Voyage `voyage-4-large` (1024-2048 dims, ~3-4× more dense tokens than OpenAI tiktoken). +- **Reranking pair**: Voyage (their reranker `rerank-2.5` pairs cleanly with Voyage embeddings). +- **Enterprise compliance**: Azure OpenAI (data residency + private endpoints) or self-hosted via llama-server / Ollama. +- **China region**: DashScope (Alibaba) or Zhipu (BigModel). DashScope's international endpoint at `dashscope-intl.aliyuncs.com`; override `provider_base_urls.dashscope` for the China endpoint. +- **OSS local, full control**: llama-server (`llama.cpp`) for any GGUF model; Ollama for the curated catalog. +- **Anything else**: LiteLLM proxy. Run LiteLLM in front of any provider (Bedrock, Vertex, Cohere, Jina, Fireworks, etc.) and point gbrain at it via `LITELLM_BASE_URL`. + +## Per-provider details + +### OpenAI + +Default. Set `OPENAI_API_KEY`. Models: `text-embedding-3-large` (3072 max, 1536 default), `text-embedding-3-small` (1536). Matryoshka via the `dimensions` field — gbrain pins it from `embedding_dimensions` config so existing 1536-dim brains stay aligned across SDK upgrades. + +### Voyage AI + +Best-in-class quality on the Voyage 4 family (Jan 2026 release). Set `VOYAGE_API_KEY`. Models: `voyage-4-large`, `voyage-4`, `voyage-4-lite`, `voyage-4-nano`, `voyage-3.5`, `voyage-code-3` (code-tuned), `voyage-finance-2`, `voyage-law-2`, `voyage-multimodal-3` (text + image). + +Voyage 4 family shares an embedding space across all variants, so you can index with `voyage-4-large` and query with `voyage-4-lite` without reindexing. Dims: 256, 512, 1024, 2048. **2048 exceeds pgvector's HNSW cap of 2000** — those brains fall back to exact vector scans (still correct, just slower). + +### Google Gemini + +Set `GOOGLE_GENERATIVE_AI_API_KEY` (the AI Studio public API key). Model: `gemini-embedding-001`. Default 768 dims; Matryoshka up to 3072. Cheap. + +For GCP service-account / Vertex AI auth (production deployments), see the v0.32.x follow-up — Vertex ADC is on the roadmap. + +### Azure OpenAI + +Enterprise OpenAI behind Azure tenancy. Required env: `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_ENDPOINT` (e.g. `https://my-resource.openai.azure.com`), `AZURE_OPENAI_DEPLOYMENT` (the deployment name from your Azure portal). Optional: `AZURE_OPENAI_API_VERSION` (defaults to `2024-10-21`). + +Unlike vanilla OpenAI, Azure uses `api-key:` header (not `Authorization: Bearer`) and a templated URL with `?api-version=` query param — gbrain handles both via the recipe's resolveAuth + resolveOpenAICompatConfig overrides. + +Models: `text-embedding-3-large`, `text-embedding-3-small`, `text-embedding-ada-002` (your Azure deployment must serve the requested model). + +### MiniMax (海螺AI) + +Set `MINIMAX_API_KEY`. Optional `MINIMAX_GROUP_ID` for org-scoped accounts. Model: `embo-01` (1536 dims). + +MiniMax's API takes a `type: 'db' | 'query'` field for asymmetric retrieval. v0.32 routes everything as `type='db'` (symmetric retrieval — same vector space for indexing and queries). Asymmetric query support is a v0.32.x follow-up. + +### DashScope (Alibaba) + +Set `DASHSCOPE_API_KEY`. International endpoint at `dashscope-intl.aliyuncs.com` by default; override `provider_base_urls.dashscope` for the China endpoint. Models: `text-embedding-v3` (current; Matryoshka 64-1024 dims), `text-embedding-v2`. + +CJK-dominant content tokenizes denser than OpenAI tiktoken; gbrain declares `chars_per_token: 2` so the batch pre-split leaves headroom. + +### Zhipu AI (BigModel) + +Set `ZHIPUAI_API_KEY`. Models: `embedding-3` (current; Matryoshka 256-2048 dims), `embedding-2`. v0.32 default is 1024 (HNSW-compatible). The 2048-dim option works but falls into the exact-scan branch (see Voyage 4 Large note above). + +### Ollama (local) + +No env required — Ollama runs unauthenticated locally. Optional `OLLAMA_BASE_URL` (default `http://localhost:11434/v1`) and `OLLAMA_API_KEY` (for auth-enabled deployments). + +Recipe ships with `nomic-embed-text` (768d, recommended), `mxbai-embed-large` (1024d), `all-minilm` (384d). `gbrain providers test --model ollama:nomic-embed-text` smoke-tests the local install. + +### llama-server (local, llama.cpp) + +`llama.cpp`'s `llama-server --embeddings` endpoint. No env required. Optional `LLAMA_SERVER_BASE_URL` (default `http://localhost:8080/v1`) and `LLAMA_SERVER_API_KEY`. + +User-driven models: launch llama-server with `--model --embeddings`, then run `gbrain init --embedding-model llama-server: --embedding-dimensions `. The recipe refuses the implicit shorthand `--model llama-server` because there's no canonical first model. + +### LiteLLM proxy (universal escape hatch) + +Run [LiteLLM](https://docs.litellm.ai/docs/proxy/quick_start) in front of any provider — Bedrock, Vertex, Cohere, Jina, Fireworks, OctoAI, etc. The proxy normalizes everything to the OpenAI-compatible API; gbrain points at the proxy via `LITELLM_BASE_URL` and proxies the call. + +This is the catch-all for "my provider isn't in the list above." Set up LiteLLM, then `gbrain init --embedding-model litellm: --embedding-dimensions `. + +## Choosing dimensions + +Three numbers matter: +1. **Provider's native dims**: each model has a "true" output dim (e.g. OpenAI `text-embedding-3-large` is 3072 native). +2. **Matryoshka reductions**: most modern providers let you request a smaller vector via the `dimensions` field. +3. **HNSW cap**: pgvector's HNSW index supports up to 2000 dims. Brains above that fall back to exact vector scans (slower but correct; gbrain handles the SQL automatically via `chunkEmbeddingIndexSql` in `src/core/vector-index.ts`). + +For most users: **stay at 1024 or 1536**. Bigger isn't better below the noise floor; smaller saves disk + RAM with marginal recall loss on Matryoshka providers. + +## My provider isn't listed + +Three options: + +1. **Use LiteLLM proxy** (above) — the universal escape hatch. Works for 100+ providers. +2. **Open a feature request** at [github.com/garrytan/gbrain/issues](https://github.com/garrytan/gbrain/issues) with the provider's API docs URL and a setup snippet. Recipes are ~30-40 lines of TypeScript. +3. **Submit a recipe**: clone, copy `src/core/ai/recipes/voyage.ts` as the gold-standard openai-compat template, register in `src/core/ai/recipes/index.ts`, add a per-recipe smoke test under `test/ai/recipe-.test.ts`. The recipe contract test (`test/ai/recipes-contract.test.ts`) and IRON RULE regression test pin the structural invariants. + +## Switching providers on an existing brain + +Embedding dimensions are baked into the schema at `gbrain init` time. To change providers post-init, you usually need to re-embed: + +1. Update config: `gbrain config set embedding_model :` and `embedding_dimensions `. +2. Reindex schema if dims changed: `gbrain doctor` will detect the mismatch and print the exact `ALTER TABLE` recipe. +3. Re-embed: `gbrain embed --all` (or `--stale` for incremental). + +`gbrain doctor` 8c "alternative_providers" surfaces unconfigured providers whose env is already set — useful when you've configured OpenAI but also have e.g. `VOYAGE_API_KEY` exported and want to know you can switch without extra setup. diff --git a/package.json b/package.json index 4341ba685..e16f32987 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "gbrain", - "version": "0.31.1", + "version": "0.32.0", "description": "Postgres-native personal knowledge brain with hybrid RAG search", "type": "module", "main": "src/core/index.ts",