Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(embedding): preserve batching and concurrency limits for WeKnoraCloud

wizardchenca88fe74aebe
diff --git a/internal/models/embedding/embedder.go b/internal/models/embedding/embedder.go
index 3e421a7c8..8f40f79f2 100644
--- a/internal/models/embedding/embedder.go
+++ b/internal/models/embedding/embedder.go
@@ -258,7 +258,7 @@ func newEmbedder(config Config, pooler EmbedderPooler, ollamaService *ollama.Oll
embedder, err = zhipuEmb, zErr
return embedder, err
case provider.ProviderWeKnoraCloud:
- embedder, err = NewWeKnoraCloudEmbedder(config)
+ embedder, err = NewWeKnoraCloudEmbedder(config, pooler)
return embedder, err
default:
// Use OpenAI-compatible embedder for other providers
diff --git a/internal/models/embedding/weknoracloud.go b/internal/models/embedding/weknoracloud.go
index f5c855442..c521753d4 100644
--- a/internal/models/embedding/weknoracloud.go
+++ b/internal/models/embedding/weknoracloud.go
@@ -32,7 +32,7 @@ type WeKnoraCloudEmbedder struct {
}
// NewWeKnoraCloudEmbedder 构造 WeKnoraCloudEmbedder
-func NewWeKnoraCloudEmbedder(config Config) (*WeKnoraCloudEmbedder, error) {
+func NewWeKnoraCloudEmbedder(config Config, pooler EmbedderPooler) (*WeKnoraCloudEmbedder, error) {
if config.AppID == "" {
return nil, fmt.Errorf("WeKnoraCloud embedder: AppID is required")
}
@@ -60,6 +60,7 @@ func NewWeKnoraCloudEmbedder(config Config) (*WeKnoraCloudEmbedder, error) {
dimensions: config.Dimensions,
supportsDimensionOverride: config.SupportsDimensionOverride,
client: newEmbeddingHTTPClient(60 * time.Second),
+ EmbedderPooler: pooler,
}, nil
}
@@ -153,10 +154,6 @@ func (e *WeKnoraCloudEmbedder) BatchEmbed(ctx context.Context, texts []string) (
return result, nil
}
-func (e *WeKnoraCloudEmbedder) BatchEmbedWithPool(ctx context.Context, model Embedder, texts []string) ([][]float32, error) {
- return e.BatchEmbed(ctx, texts)
-}
-
func (e *WeKnoraCloudEmbedder) SetSupportsDimensionOverride(supported bool) {
e.supportsDimensionOverride = supported
}
diff --git a/internal/models/embedding/weknoracloud_batch_test.go b/internal/models/embedding/weknoracloud_batch_test.go
new file mode 100644
index 000000000..cb8291b03
--- /dev/null
+++ b/internal/models/embedding/weknoracloud_batch_test.go
@@ -0,0 +1,142 @@
+package embedding
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "reflect"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/Tencent/WeKnora/internal/models/limiter"
+ "github.com/Tencent/WeKnora/internal/models/provider"
+ "github.com/Tencent/WeKnora/internal/types"
+ secutils "github.com/Tencent/WeKnora/internal/utils"
+ "github.com/panjf2000/ants/v2"
+)
+
+type cloudBatchTestTransport func(*http.Request) (*http.Response, error)
+
+func (f cloudBatchTestTransport) RoundTrip(r *http.Request) (*http.Response, error) {
+ return f(r)
+}
+
+// Exercise the factory's pool wiring and the concurrency wrapper with an
+// in-memory transport; no requests reach the configured address.
+func newCloudBatchTestEmbedder(t *testing.T, transport cloudBatchTestTransport) Embedder {
+ t.Helper()
+ t.Setenv("SSRF_WHITELIST", "cloud-batch.invalid")
+ secutils.ResetSSRFWhitelistForTest()
+ t.Cleanup(secutils.ResetSSRFWhitelistForTest)
+ pool, err := ants.NewPool(4)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(pool.Release)
+ raw, err := newEmbedder(Config{
+ Source: types.ModelSourceRemote, Provider: string(provider.ProviderWeKnoraCloud),
+ BaseURL: "https://cloud-batch.invalid", ModelID: "cloud-batch-test", ModelName: "test",
+ AppID: "test-app", AppSecret: "test-secret",
+ }, NewBatchEmbedder(pool), nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ raw.(*WeKnoraCloudEmbedder).client = &http.Client{Transport: transport}
+ return wrapEmbeddingConcurrency(raw, 1)
+}
+
+func TestWeKnoraCloudPoolBatchesAndPreservesOrder(t *testing.T) {
+ t.Setenv("BATCH_EMBED_SIZE", "2")
+ var mu sync.Mutex
+ var sizes []int
+ embedder := newCloudBatchTestEmbedder(t, func(r *http.Request) (*http.Response, error) {
+ var input weKnoraCloudEmbedRequest
+ if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+ return nil, err
+ }
+ mu.Lock()
+ sizes = append(sizes, len(input.Input))
+ mu.Unlock()
+ // Return provider entries in reverse order to exercise both index
+ // restoration within a batch and ordered reassembly across batches.
+ entries := make([]string, 0, len(input.Input))
+ for i := len(input.Input) - 1; i >= 0; i-- {
+ entries = append(entries, fmt.Sprintf(`{"index":%d,"embedding":[%d]}`, i, len(input.Input[i])))
+ }
+ return &http.Response{
+ StatusCode: http.StatusOK,
+ Body: io.NopCloser(strings.NewReader(`{"data":[` + strings.Join(entries, ",") + `]}`)),
+ }, nil
+ })
+ got, err := embedder.BatchEmbedWithPool(context.Background(), embedder, []string{"a", "bb", "ccc", "dddd", "eeeee"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if want := [][]float32{{1}, {2}, {3}, {4}, {5}}; !reflect.DeepEqual(got, want) {
+ t.Fatalf("embeddings = %v, want %v", got, want)
+ }
+ if len(sizes) != 3 {
+ t.Fatalf("request sizes = %v, want three batches", sizes)
+ }
+ for _, size := range sizes {
+ if size < 1 || size > 2 {
+ t.Fatalf("request size %d violates BATCH_EMBED_SIZE=2", size)
+ }
+ }
+}
+
+func TestWeKnoraCloudPoolHonoursConcurrencyLimit(t *testing.T) {
+ t.Setenv("BATCH_EMBED_SIZE", "1")
+ limiter.SetGovernor(limiter.NewLocalLimiter(), 10)
+ t.Cleanup(func() { limiter.SetGovernor(nil, 0) })
+ entered := make(chan struct{}, 2)
+ release := make(chan struct{})
+ embedder := newCloudBatchTestEmbedder(t, func(*http.Request) (*http.Response, error) {
+ entered <- struct{}{}
+ <-release
+ return &http.Response{
+ StatusCode: http.StatusOK,
+ Body: io.NopCloser(strings.NewReader(`{"data":[{"index":0,"embedding":[1]}]}`)),
+ }, nil
+ })
+ ctx := types.WithBackgroundTask(context.Background())
+ var wg sync.WaitGroup
+ var once sync.Once
+ unblock := func() { once.Do(func() { close(release) }) }
+ t.Cleanup(func() { unblock(); wg.Wait() })
+ errs := make(chan error, 2)
+ // Separate callers represent simultaneous wiki batches sharing a model.
+ for range 2 {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ _, err := embedder.BatchEmbedWithPool(ctx, embedder, []string{"x"})
+ errs <- err
+ }()
+ }
+ select {
+ case <-entered:
+ case <-time.After(2 * time.Second):
+ t.Fatal("first provider request did not enter")
+ }
+ select {
+ case <-entered:
+ t.Error("two provider requests entered concurrently with model limit=1")
+ case <-time.After(150 * time.Millisecond):
+ }
+ unblock()
+ for range 2 {
+ select {
+ case err := <-errs:
+ if err != nil {
+ t.Error(err)
+ }
+ case <-time.After(2 * time.Second):
+ t.Fatal("pooled embedding did not complete after release")
+ }
+ }
+}