@eucoder/rag 0.2.0 → 0.3.1

package/src/qdrant-store.ts

@@ -0,0 +1,114 @@
+export interface QdrantFilter {
+  [key: string]: unknown;
+}
+
+export interface QdrantSearchResult {
+  id: string;
+  score: number;
+  payload?: Record<string, unknown>;
+}
+
+export class QdrantVectorStore {
+  private baseUrl: string = "";
+  private apiKey?: string;
+
+  connect(url: string, apiKey?: string): void {
+    this.baseUrl = url.replace(/\/$/, "");
+    this.apiKey = apiKey;
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = { "Content-Type": "application/json" };
+    if (this.apiKey) h["api-key"] = this.apiKey;
+    return h;
+  }
+
+  private async request(path: string, init?: RequestInit): Promise<unknown> {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: { ...this.headers(), ...((init?.headers as Record<string, string>) || {}) },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Qdrant error ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return undefined;
+    return res.json();
+  }
+
+  async addVectors(
+    ids: string[],
+    vectors: number[][],
+    payloads: Record<string, unknown>[]
+  ): Promise<void> {
+    const dims = vectors[0]?.length ?? 0;
+    if (!dims || ids.length !== vectors.length || vectors.length !== payloads.length) {
+      throw new Error("Invalid addVectors arguments: mismatched lengths or empty vectors");
+    }
+
+    const collection = "eucode_chunks";
+
+    try {
+      await this.request(`/collections/${collection}`);
+    } catch (e: any) {
+      if (e.message?.includes("404") || e.message?.includes("Not found")) {
+        await this.request(`/collections/${collection}`, {
+          method: "PUT",
+          body: JSON.stringify({
+            vectors: { size: dims, distance: "Cosine" },
+          }),
+        });
+      } else {
+        throw e;
+      }
+    }
+
+    await this.request(`/collections/${collection}/points?wait=true`, {
+      method: "PUT",
+      body: JSON.stringify({
+        points: ids.map((id, i) => ({
+          id,
+          vector: vectors[i],
+          payload: payloads[i],
+        })),
+      }),
+    });
+  }
+
+  async search(
+    vector: number[],
+    topK: number,
+    filter?: QdrantFilter
+  ): Promise<QdrantSearchResult[]> {
+    const collection = "eucode_chunks";
+    const body: Record<string, unknown> = {
+      vector,
+      limit: topK,
+      with_payload: true,
+    };
+    if (filter) {
+      body.filter = filter;
+    }
+
+    const result = (await this.request(`/collections/${collection}/points/search`, {
+      method: "POST",
+      body: JSON.stringify(body),
+    })) as {
+      result?: Array<{
+        id: string | number;
+        score: number;
+        payload?: Record<string, unknown>;
+      }>;
+    };
+
+    return (result.result ?? []).map((r) => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload,
+    }));
+  }
+
+  async deleteCollection(name: string): Promise<void> {
+    await this.request(`/collections/${name}`, { method: "DELETE" });
+  }
+}

package/src/types.ts

@@ -88,6 +88,20 @@ export interface KnowledgeGraph {
   getConnectedEntities(entityId: string, depth?: number): Entity[];
 }
 
+export interface AsyncKnowledgeGraph {
+  addEntity(entity: Entity): Promise<void>;
+  addRelation(relation: Relation): Promise<void>;
+  getEntity(id: string): Promise<Entity | undefined>;
+  getRelations(entityId: string): Promise<Relation[]>;
+  getConnectedEntities(entityId: string, depth?: number): Promise<Entity[]>;
+  searchEntities(query: { name?: string; type?: string }): Promise<Entity[]>;
+  deleteEntity(entityId: string): Promise<void>;
+  deleteRelation(relationId: string): Promise<void>;
+  getStats(): Promise<{ entityCount: number; relationCount: number }>;
+  clear(): Promise<void>;
+  close(): Promise<void>;
+}
+
 export interface EntityExtractor {
   extract(text: string): Promise<Entity[]>;
 }