Function embedMultiSector

backend/src/memory/embed.ts:543–616

(
    id: string,
    txt: string,
    secs: string[],
    chunks?: Array<{ text: string }>,
)

};

export async function embedMultiSector(
    id: string,
    txt: string,
    secs: string[],
    chunks?: Array<{ text: string }>,
): Promise<EmbeddingResult[]> {
    const r: EmbeddingResult[] = [];
    await q.ins_log.run(id, "multi-sector", "pending", Date.now(), null);
    for (let a = 0; a < 3; a++) {
        try {
            const simp = env.embed_mode === "simple";
            if (
                simp &&
                (env.emb_kind === "gemini" || env.emb_kind === "openai")
            ) {
                console.log(
                    `[EMBED] Simple mode (1 batch for ${secs.length} sectors)`,
                );
                const tb: Record<string, string> = {};
                secs.forEach((s) => (tb[s] = txt));
                // Use batch embedding with fallback support
                const b = await emb_batch_with_fallback(tb);
                Object.entries(b).forEach(([s, v]) =>
                    r.push({ sector: s, vector: v, dim: v.length }),
                );
            } else {
                console.log(`[EMBED] Advanced mode (${secs.length} calls)`);
                const par = env.adv_embed_parallel && env.emb_kind !== "gemini";
                if (par) {
                    const p = secs.map(async (s) => {
                        let v: number[];
                        if (chunks && chunks.length > 1) {
                            const cv: number[][] = [];
                            for (const c of chunks)
                                cv.push(await embedForSector(c.text, s));
                            v = agg_chunks(cv);
                        } else v = await embedForSector(txt, s);
                        return { sector: s, vector: v, dim: v.length };
                    });
                    r.push(...(await Promise.all(p)));
                } else {
                    for (let i = 0; i < secs.length; i++) {
                        const s = secs[i];
                        let v: number[];
                        if (chunks && chunks.length > 1) {
                            const cv: number[][] = [];
                            for (const c of chunks)
                                cv.push(await embedForSector(c.text, s));
                            v = agg_chunks(cv);
                        } else v = await embedForSector(txt, s);
                        r.push({ sector: s, vector: v, dim: v.length });
                        if (env.embed_delay_ms > 0 && i < secs.length - 1)
                            await new Promise((x) =>
                                setTimeout(x, env.embed_delay_ms),
                            );
                    }
                }
            }