fix vectorDBInstance not returning texts properly.

support mode embedding models for Google Gemini.
add vectordb documentation

Author: alaa-eddine

examples/01-agent-code-skill/04.1-chat-planner-coder.ts

@@ -1,7 +1,7 @@
 import { Agent, Chat, Component, Model, TAgentMode, TLLMEvent } from '@smythos/sdk';
 import chalk from 'chalk';
 import * as readline from 'readline';
-import { EmitUnit, PluginBase, TokenLoom } from 'tokenloom';
+import { EmitUnit, PluginAPI, PluginBase, TokenLoom } from 'tokenloom';
 
 //Show the tasks list and status to the user at every step before performing the tasks, and also give a tasks status summary after tasks.
 //When you display the tasks list to a user show it in a concise way with a summary and checkboxes for each task.

examples/05-VectorDB-with-agent/01-upsert-and-search.ts

@@ -16,6 +16,7 @@ const pineconeSettings = {
     indexName: 'demo-vec',
     apiKey: process.env.PINECONE_API_KEY,
     embeddings: Model.OpenAI('text-embedding-3-large'),
+    //you can also use Model.GoogleAI('gemini-embedding-001', { dimensions: 1024 })
 };
 
 async function createAgent() {

examples/06-Storage-no-agent/01-localstorage.ts

@@ -2,16 +2,14 @@ import { Storage } from '@smythos/sdk';
 
 async function main() {
     const localStorage = Storage.LocalStorage();
-        
+
     await localStorage.write('test.txt', 'Hello, world!');
 
     const data = await localStorage.read('test.txt');
 
     const dataAsString = data.toString();
 
     console.log(dataAsString);
-
-
 }
 
-main();
+main();

examples/11-zoom-rtms-integration/types.d.ts

@@ -1,88 +1,71 @@
 // Global type declarations for Node.js environment
 declare global {
-  namespace NodeJS {
-    interface ProcessEnv {
-      PORT?: string;
-      ZOOM_SECRET_TOKEN?: string;
-      ZOOM_CLIENT_ID?: string;
-      ZOOM_CLIENT_SECRET?: string;
-      WEBHOOK_PATH?: string;
-      OPENAI_API_KEY?: string;
-      ANTHROPIC_API_KEY?: string;
-      PINECONE_API_KEY?: string;
-      PINECONE_INDEX_NAME?: string;
-      AWS_ACCESS_KEY_ID?: string;
-      AWS_SECRET_ACCESS_KEY?: string;
-      AWS_REGION?: string;
-      AWS_S3_BUCKET?: string;
-      LOG_LEVEL?: string;
+    namespace NodeJS {
+        interface ProcessEnv {
+            PORT?: string;
+            ZOOM_SECRET_TOKEN?: string;
+            ZOOM_CLIENT_ID?: string;
+            ZOOM_CLIENT_SECRET?: string;
+            WEBHOOK_PATH?: string;
+            OPENAI_API_KEY?: string;
+            ANTHROPIC_API_KEY?: string;
+            PINECONE_API_KEY?: string;
+            PINECONE_INDEX_NAME?: string;
+            AWS_ACCESS_KEY_ID?: string;
+            AWS_SECRET_ACCESS_KEY?: string;
+            AWS_REGION?: string;
+            AWS_S3_BUCKET?: string;
+            LOG_LEVEL?: string;
+        }
     }
-  }
 
-  var process: NodeJS.Process;
-  var console: Console;
-  var Buffer: BufferConstructor;
-}
-
-// Module declarations for packages that might not have types
-declare module '@smythos/sdk' {
-  export class Agent {
-    constructor(config: any);
-    addSkill(skill: any): void;
-    prompt(message: string): Promise<string>;
-    llm: any;
-    storage: any;
-    vectordb: any;
-  }
-  
-  export class Model {
-    static OpenAI(model: string): any;
-    static Anthropic(model: string): any;
-  }
+    var process: NodeJS.Process;
+    var console: Console;
+    var Buffer: BufferConstructor;
 }
 
 declare module 'crypto' {
-  export function createHmac(algorithm: string, key: string): any;
+    export function createHmac(algorithm: string, key: string): any;
 }
 
 declare module 'ws' {
-  export default class WebSocket {
-    constructor(url: string, options?: any);
-    on(event: string, callback: Function): void;
-    send(data: string): void;
-    close(): void;
-  }
+    export default class WebSocket {
+        constructor(url: string, options?: any);
+        on(event: string, callback: Function): void;
+        send(data: string): void;
+        close(): void;
+    }
 }
 
 declare module 'express' {
-  export interface Request {
-    body: any;
-  }
-  
-  export interface Response {
-    json(data: any): void;
-    sendStatus(code: number): void;
-  }
-  
-  interface Express {
-    use(middleware: any): void;
-    post(path: string, handler: any): void;
-    get(path: string, handler: any): void;
-    listen(port: string | number, callback?: () => void): void;
-  }
-  
-  interface ExpressStatic {
-    (): Express;
-    json(): any;
-  }
-  
-  const express: ExpressStatic;
-  export default express;
-  export { Request, Response };
+    export interface Request {
+        body: any;
+    }
+
+    export interface Response {
+        json(data: any): void;
+        sendStatus(code: number): void;
+    }
+
+    interface Express {
+        use(middleware: any): void;
+        post(path: string, handler: any): void;
+        get(path: string, handler: any): void;
+        listen(port: string | number, callback?: () => void): void;
+    }
+
+    interface ExpressStatic {
+        (): Express;
+        json(): any;
+    }
+
+    const express: ExpressStatic;
+    export default express;
+    export { Request, Response };
 }
 
 declare module 'dotenv' {
-  export function config(): void;
+    export function config(): void;
 }
 
 export {};

packages/core/src/subsystems/IO/VectorDB.service/embed/GoogleEmbedding.ts

@@ -1,4 +1,4 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GoogleGenAI } from '@google/genai';
 import { BaseEmbedding, TEmbeddings } from './BaseEmbedding';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import { getLLMCredentials } from '@sre/LLMManager/LLM.service/LLMCredentials.helper';
@@ -7,9 +7,10 @@ import { TLLMCredentials, TLLMModel, BasicCredentials } from '@sre/types/LLM.typ
 const DEFAULT_MODEL = 'gemini-embedding-001';
 
 export class GoogleEmbeds extends BaseEmbedding {
-    protected client: GoogleGenerativeAI;
+    protected client: GoogleGenAI;
 
-    public static models = ['gemini-embedding-001'];
+    // Keep in sync with Gemini API supported embedding models
+    public static models = ['gemini-embedding-001', 'text-embedding-005', 'text-multilingual-embedding-002'];
     public canSpecifyDimensions = true;
 
     constructor(private settings?: Partial<TEmbeddings>) {
@@ -43,7 +44,7 @@ export class GoogleEmbeds extends BaseEmbedding {
 
     protected async embed(texts: string[], candidate: AccessCandidate): Promise<number[][]> {
         let apiKey: string | undefined;
-        
+
         // Try to get from credentials first
         try {
             const modelInfo: TLLMModel = {
@@ -56,37 +57,62 @@ export class GoogleEmbeds extends BaseEmbedding {
         } catch (e) {
             // If credential system fails, fall back to environment variable
         }
-        
+
         // Fall back to environment variable if not found in credentials
         if (!apiKey) {
             apiKey = process.env.GOOGLE_AI_API_KEY;
         }
-        
+
         if (!apiKey) {
             throw new Error('Please provide an API key for Google AI embeddings via credentials or GOOGLE_AI_API_KEY environment variable');
         }
 
         if (!this.client) {
-            this.client = new GoogleGenerativeAI(apiKey);
+            this.client = new GoogleGenAI({ apiKey });
         }
 
         try {
-            const model = this.client.getGenerativeModel({ model: this.model });
-            
-            const embeddings: number[][] = [];
-            
-            for (const text of texts) {
-                const result = await model.embedContent(text);
-                if (result?.embedding?.values) {
-                    embeddings.push(result.embedding.values);
-                } else {
-                    throw new Error('Invalid embedding response from Google AI');
-                }
-            }
-            
-            return embeddings;
+            const outputDimensionality = this.dimensions && Number.isFinite(this.dimensions) ? this.dimensions : undefined;
+
+            // Batch request using the new SDK
+            const res = await this.client.models.embedContent({
+                model: this.model,
+                contents: texts,
+                ...(outputDimensionality ? { outputDimensionality } : {}),
+            });
+
+            // The SDK can return either { embedding } for single or { embeddings } for batch
+            const vectors: number[][] = Array.isArray((res as any).embeddings)
+                ? (res as any).embeddings.map((e: any) => e.values as number[])
+                : [((res as any).embedding?.values as number[]) || []];
+
+            // Enforce dimensions and normalization when requested or when non-3072
+            const targetDim = outputDimensionality;
+            const processed = vectors.map((v) => this.postProcessEmbedding(v, targetDim));
+
+            return processed;
         } catch (e) {
             throw new Error(`Google Embeddings API error: ${e.message || e}`);
         }
     }
-}
+
+    private postProcessEmbedding(values: number[], targetDim?: number): number[] {
+        let v = Array.isArray(values) ? values.slice() : [];
+        if (targetDim && targetDim > 0) {
+            if (v.length > targetDim) {
+                // SDK ignored smaller dimension: truncate
+                v = v.slice(0, targetDim);
+            } else if (v.length < targetDim) {
+                // SDK returned shorter vector: pad with zeros
+                v = v.concat(Array(targetDim - v.length).fill(0));
+            }
+        }
+        // Normalize for non-default 3072 dims (recommended by Google docs)
+        const needNormalize = (targetDim && targetDim !== 3072) || (!targetDim && v.length !== 3072);
+        if (needNormalize && v.length > 0) {
+            const norm = Math.sqrt(v.reduce((acc, x) => acc + x * x, 0));
+            if (norm > 0) v = v.map((x) => x / norm);
+        }
+        return v;
+    }
+}