@ai.ntellect/core 0.5.0 → 0.6.1

package/memory/persistent.ts

@@ -1,265 +0,0 @@
-import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
-import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import { LongTermMemory, MemoryScope } from "../types";
-
-interface SearchOptions {
-  scope?: MemoryScope;
-  userId?: string;
-  maxResults?: number;
-  similarityThreshold?: number;
-}
-
-interface MeilisearchSettings {
-  searchableAttributes?: string[];
-  sortableAttributes?: string[];
-}
-
-interface MeilisearchResponse {
-  hits: Array<{
-    createdAt: string;
-    query: string;
-    purpose: string;
-    data?: any;
-    chunks: Array<{
-      content: string;
-      embedding: number[];
-    }>;
-  }>;
-}
-
-interface ProcessedChunk {
-  content: string;
-  embedding: number[];
-}
-
-/**
- * Handles persistent memory storage using Meilisearch API
- */
-export class PersistentMemory {
-  private readonly host: string;
-  private readonly apiKey: string;
-  private readonly INDEX_PREFIX: string;
-  private readonly embeddingModel: EmbeddingModel<string>;
-  constructor(options: {
-    host: string;
-    apiKey: string;
-    indexPrefix?: string;
-    embeddingModel: EmbeddingModel<string>;
-  }) {
-    this.host = options.host;
-    this.apiKey = options.apiKey;
-    this.INDEX_PREFIX = options.indexPrefix || "memory";
-    this.embeddingModel = options.embeddingModel;
-  }
-
-  /**
-   * Initialize indexes
-   */
-  async init() {
-    try {
-      // Create or get main index
-      await this._getOrCreateIndex(this.INDEX_PREFIX);
-      console.log(`✅ Index '${this.INDEX_PREFIX}' initialized successfully`);
-    } catch (error) {
-      console.error(`❌ Failed to initialize index: ${error}`);
-      throw error;
-    }
-  }
-
-  /**
-   * Make API request to Meilisearch
-   */
-  private async _makeRequest<T = unknown>(
-    path: string,
-    options: RequestInit = {}
-  ): Promise<T> {
-    const url = `${this.host}${path}`;
-    console.log("🔍 Making request to Meilisearch:", url);
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...options.headers,
-      },
-    });
-
-    if (!response.ok) {
-      console.log({ response });
-      throw new Error(`Meilisearch API error: ${response.statusText}`);
-    }
-
-    return response.json() as Promise<T>;
-  }
-
-  /**
-   * Get or create an index with proper settings
-   */
-  private async _getOrCreateIndex(indexName: string) {
-    try {
-      // Check if index exists first
-      const indexExists = await this._makeRequest(`/indexes/${indexName}`, {
-        method: "GET",
-      }).catch(() => false);
-
-      if (!indexExists) {
-        console.log(`Creating new index: ${indexName}`);
-        await this._makeRequest("/indexes", {
-          method: "POST",
-          body: JSON.stringify({
-            uid: indexName,
-            primaryKey: "id",
-          }),
-        });
-      }
-
-      // Update index settings
-      const settings: MeilisearchSettings = {
-        searchableAttributes: ["query", "purpose", "chunks.content"],
-        sortableAttributes: ["createdAt"],
-      };
-
-      await this._makeRequest(`/indexes/${indexName}/settings`, {
-        method: "PATCH",
-        body: JSON.stringify(settings),
-      });
-
-      console.log(`Index ${indexName} configured successfully`);
-    } catch (error: any) {
-      console.error(`Failed to configure index ${indexName}:`, error);
-      throw error;
-    }
-  }
-
-  async processContent(content: string): Promise<ProcessedChunk[]> {
-    // Split content into chunks
-    const textSplitter = new RecursiveCharacterTextSplitter({
-      chunkSize: 1000,
-    });
-    const chunks = await textSplitter.createDocuments([content]);
-
-    // Generate embeddings for all chunks
-    const { embeddings } = await embedMany({
-      model: this.embeddingModel,
-      values: chunks.map((chunk) => chunk.pageContent),
-    });
-
-    // Create processed chunks with embeddings
-    return chunks.map((chunk, i) => ({
-      content: chunk.pageContent,
-      embedding: embeddings[i],
-    }));
-  }
-
-  /**
-   * Store a memory in the database
-   */
-  async createMemory(memory: LongTermMemory) {
-    try {
-      console.log(`📝 Creating memory in index: ${this.INDEX_PREFIX}`);
-
-      // Process content into chunks with embeddings
-      const chunks = await this.processContent(memory.data);
-
-      // Generate unique ID if not provided
-      const id = memory.id || crypto.randomUUID();
-
-      const document = {
-        ...memory,
-        chunks,
-        createdAt: memory.createdAt.toISOString(),
-      };
-
-      const response = await this._makeRequest(
-        `/indexes/${this.INDEX_PREFIX}/documents`,
-        {
-          method: "POST",
-          body: JSON.stringify([document]),
-        }
-      );
-
-      console.log("✅ Memory created successfully", { id });
-      return response;
-    } catch (error) {
-      console.error("❌ Failed to create memory:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Find best matching memories
-   */
-  async findRelevantDocuments(query: string, options: SearchOptions = {}) {
-    console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
-    console.log("Query:", query);
-
-    try {
-      // Generate embedding for the query
-      const { embedding: queryEmbedding } = await embed({
-        model: this.embeddingModel,
-        value: query,
-      });
-
-      // Search in the index
-      const searchResults = await this._makeRequest<MeilisearchResponse>(
-        `/indexes/${this.INDEX_PREFIX}/search`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            q: query,
-            limit: options.maxResults || 10,
-          }),
-        }
-      );
-
-      if (!searchResults?.hits?.length) {
-        console.log("❌ No matches found");
-        return [];
-      }
-
-      // Process and filter results using cosine similarity
-      const results = searchResults.hits
-        .flatMap((hit) => {
-          const chunkSimilarities = hit.chunks.map((chunk) => ({
-            query: hit.query,
-            data: hit.data,
-            similarityPercentage:
-              (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
-            createdAt: hit.createdAt,
-          }));
-
-          return chunkSimilarities.reduce(
-            (best, current) =>
-              current.similarityPercentage > best.similarityPercentage
-                ? current
-                : best,
-            chunkSimilarities[0]
-          );
-        })
-        .filter(
-          (match) =>
-            match.similarityPercentage >= (options.similarityThreshold || 70)
-        )
-        .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-
-      console.log(`✨ Found ${results.length} relevant matches`);
-      return results.map((result) => ({
-        query: result.query,
-        data: result.data,
-        createdAt: result.createdAt,
-      }));
-    } catch (error) {
-      console.error("❌ Search failed:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Delete memories for a given scope and user
-   */
-  async deleteMemories() {
-    return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
-      method: "DELETE",
-    });
-  }
-}

package/script.js

@@ -1,167 +0,0 @@
-// Dimensions de l'espace SVG
-const width = 800;
-const height = 600;
-
-// Exemple de données pour les nœuds et les arêtes
-const nodes = [
-  { id: "fetchData", name: "Fetch Data", group: 1, selected: false },
-  { id: "analyzeData", name: "Analyze Data", group: 1, selected: false },
-  { id: "sendAlert", name: "Send Alert", group: 1, selected: false },
-];
-
-const links = [
-  { source: "fetchData", target: "analyzeData" },
-  { source: "analyzeData", target: "sendAlert" },
-];
-
-// Simulation de force
-const simulation = d3
-  .forceSimulation(nodes)
-  .force(
-    "link",
-    d3.forceLink(links).id((d) => d.id)
-  )
-  .force("charge", d3.forceManyBody().strength(-300))
-  .force("center", d3.forceCenter(width / 2, height / 2));
-
-// Créer le conteneur SVG
-const svg = d3.select("#graph").attr("width", width).attr("height", height);
-
-// Groupes pour liens et nœuds
-const linkGroup = svg
-  .append("g")
-  .attr("class", "links")
-  .attr("stroke", "#999")
-  .attr("stroke-opacity", 0.6);
-
-const nodeGroup = svg.append("g").attr("class", "nodes");
-
-// Fonction pour mettre à jour le graphe
-function updateGraph() {
-  // Mettre à jour les liens
-  const link = linkGroup.selectAll("line").data(links);
-
-  link
-    .enter()
-    .append("line")
-    .attr("stroke-width", 2)
-    .merge(link)
-    .attr("x1", (d) => d.source.x)
-    .attr("y1", (d) => d.source.y)
-    .attr("x2", (d) => d.target.x)
-    .attr("y2", (d) => d.target.y);
-
-  link.exit().remove();
-
-  // Mettre à jour les nœuds
-  const node = nodeGroup.selectAll("circle").data(nodes, (d) => d.id);
-
-  node.exit().remove();
-
-  const nodeEnter = node
-    .enter()
-    .append("circle")
-    .attr("r", 20)
-    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"))
-    .attr("stroke", "#fff")
-    .attr("stroke-width", 1.5)
-    .call(
-      d3
-        .drag()
-        .on("start", dragstarted)
-        .on("drag", dragged)
-        .on("end", dragended)
-    )
-    .on("click", nodeClicked);
-
-  nodeEnter
-    .merge(node)
-    .attr("cx", (d) => d.x)
-    .attr("cy", (d) => d.y)
-    .attr("fill", (d) => (d.selected ? "orange" : "#69b3a2"));
-
-  // Ajouter des labels
-  const label = nodeGroup.selectAll("text").data(nodes);
-
-  label.exit().remove();
-
-  label
-    .enter()
-    .append("text")
-    .attr("dy", 4)
-    .attr("dx", 25)
-    .merge(label)
-    .attr("x", (d) => d.x)
-    .attr("y", (d) => d.y)
-    .text((d) => d.name);
-
-  simulation.on("tick", () => {
-    link
-      .attr("x1", (d) => d.source.x)
-      .attr("y1", (d) => d.source.y)
-      .attr("x2", (d) => d.target.x)
-      .attr("y2", (d) => d.target.y);
-
-    node.attr("cx", (d) => d.x).attr("cy", (d) => d.y);
-
-    label.attr("x", (d) => d.x + 25).attr("y", (d) => d.y);
-  });
-
-  updateWorkflowOrder();
-}
-
-// Fonction pour mettre à jour l'ordre du workflow
-function updateWorkflowOrder() {
-  const selectedNodes = nodes.filter((node) => node.selected);
-  if (selectedNodes.length > 0) {
-    workflowOrder = selectedNodes.map((node) => node.name);
-  } else {
-    const startNode = nodes.find(
-      (node) => !links.some((link) => link.target === node.id)
-    );
-
-    if (!startNode) {
-      workflowOrder = [];
-      console.log("Workflow Order: []");
-      return;
-    }
-
-    workflowOrder = [];
-    let currentNode = startNode;
-    while (currentNode) {
-      workflowOrder.push(currentNode.name);
-      const nextLink = links.find((link) => link.source === currentNode.id);
-      currentNode = nextLink
-        ? nodes.find((node) => node.id === nextLink.target)
-        : null;
-    }
-  }
-  console.log("Workflow Order:", workflowOrder);
-}
-
-// Gestion de la sélection multiple
-function nodeClicked(event, node) {
-  node.selected = !node.selected;
-  updateGraph();
-}
-
-// Gestion du drag & drop
-function dragstarted(event, d) {
-  if (!event.active) simulation.alphaTarget(0.3).restart();
-  d.fx = d.x;
-  d.fy = d.y;
-}
-
-function dragged(event, d) {
-  d.fx = event.x;
-  d.fy = event.y;
-}
-
-function dragended(event, d) {
-  if (!event.active) simulation.alphaTarget(0);
-  d.fx = null;
-  d.fy = null;
-}
-
-// Initialisation
-updateGraph();