@ai.ntellect/core 0.6.16 → 0.6.19

package/utils/experimental-graph-rag.ts

@@ -1,170 +0,0 @@
-import { MeilisearchAdapter } from "@/memory/adapters/meilisearch";
-import { AIEmbeddingService } from "@/services/embedding";
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z } from "zod";
-
-export const experimentalGraphRag = async (context: {
-  prompt: string;
-  results: any;
-}) => {
-  if (!process.env.MEILISEARCH_API_KEY)
-    throw new Error("MEILISEARCH_API_KEY is not set");
-  if (!process.env.MEILISEARCH_HOST)
-    throw new Error("MEILISEARCH_HOST is not set");
-
-  const memoryManager = new MeilisearchAdapter({
-    apiKey: process.env.MEILISEARCH_API_KEY,
-    host: process.env.MEILISEARCH_HOST,
-  });
-  await memoryManager.init("nodes");
-  await memoryManager.init("edges");
-  const { existingNodes } = await retrieveExistingRelations(
-    memoryManager,
-    "nodes"
-  );
-  const prompt = `
-      User asked: ${context.prompt}
-      Results: ${JSON.stringify(context.results, null, 2)}
-      Existing nodes: ${JSON.stringify(existingNodes, null, 2)}
-      `;
-  console.log("🔍 Prompt:", prompt);
-  const llmMemory = await generateObject({
-    model: openai("gpt-4o"),
-    prompt,
-    schema: z.object({
-      nodes: z.array(
-        z.object({
-          name: z.string(), // Nom de l'entité (ex: Adresse, ETH, Transaction ID)
-          metadata: z.record(z.string(), z.any()), // Métadonnées associées
-        })
-      ),
-      edges: z.array(
-        z.object({
-          source: z.string(), // ID de l'entité source
-          target: z.string(), // ID de l'entité cible
-          relation: z.string(), // Type de relation (ex: "sent", "received", "on_chain")
-        })
-      ),
-    }),
-    system: `
-       You are an **AI memory manager** for a crypto wallet assistant.
-  
-  ## Rules:
-  - Nodes are entities like user, networks, tokens...etc
-  - Relations are edges like sent, uses, supported_on, loves, has_website...etc
-  - Ensure NO DUPLICATE RELATIONS.
-  - Standardize all relations using Cypher language.
-
-  Return the structured memory in JSON format, ensuring it follows the schema.
-
-        Generate structured graph data accordingly.
-
-        Format the output as a JSON object :
-        {
-          nodes: [
-            {
-              name: string,
-              metadata: Record<string, any>,
-            },
-          ],
-          edges: [
-            {
-              source: string,
-              target: string,
-              relation: string,
-            },
-          ],
-        }
-        `,
-  });
-
-  console.log("🔍 LLM memory (graph-based):");
-  console.log("Nodes:");
-  console.dir(llmMemory.object.nodes, { depth: null, colors: true });
-  console.log("Edges:");
-  console.dir(llmMemory.object.edges, { depth: null, colors: true });
-
-  const embeddingManager = new AIEmbeddingService(
-    openai.embedding("text-embedding-3-small")
-  );
-  const embedding = await embeddingManager.embedText(context.prompt);
-  let nodesNameToId: Record<string, string> = {};
-  for (const node of llmMemory.object.nodes) {
-    // Search for existing memory with same data and query
-    const searchResults = await memoryManager.search(node.name, "nodes", {
-      limit: 1,
-    });
-    const existingMemory = searchResults.find(
-      (result) =>
-        result.document.data.name === node.name &&
-        result.document.roomId === "nodes"
-    );
-
-    // If found, return existing memory
-    if (existingMemory) {
-      nodesNameToId[node.name] = existingMemory.document.id;
-    } else {
-      const nodesMemory = await memoryManager.createMemory({
-        data: node,
-        embedding,
-        roomId: "nodes",
-      });
-      nodesNameToId[node.name] = nodesMemory?.id || "";
-    }
-  }
-  for (const edge of llmMemory.object.edges) {
-    // Verify if source and target already exist in memory
-    const searchResults = await memoryManager.search(
-      nodesNameToId[edge.source],
-      "edges",
-      {
-        limit: 100,
-      }
-    );
-    const existingEdge = searchResults.find(
-      (result) =>
-        result.document.data.source === nodesNameToId[edge.source] &&
-        result.document.data.target === nodesNameToId[edge.target] &&
-        result.document.data.relation === edge.relation
-    );
-    if (existingEdge) {
-    } else {
-      await memoryManager.createMemory({
-        data: {
-          source: nodesNameToId[edge.source],
-          target: nodesNameToId[edge.target],
-          relation: edge.relation,
-        },
-        embedding,
-        roomId: "edges",
-      });
-    }
-  }
-};
-
-async function retrieveExistingRelations(
-  memoryManager: MeilisearchAdapter,
-  roomId: string
-) {
-  const existingNodesMemories = await memoryManager.getAllMemories("nodes");
-  const existingEdgesMemories = await memoryManager.getAllMemories("edges");
-  let existingNodes: any[] = [];
-  let existingEdges: any[] = [];
-
-  if (existingNodesMemories.length > 0) {
-    existingNodes = existingNodesMemories.flatMap((memory) => {
-      return {
-        id: memory.id,
-        data: memory.data,
-      };
-    });
-  }
-  if (existingEdgesMemories.length > 0) {
-    existingEdges = existingEdgesMemories.flatMap(
-      (memory) => memory.data || []
-    );
-  }
-
-  return { existingNodes, existingEdges };
-}

package/utils/generate-object.ts

@@ -1,117 +0,0 @@
-import { CoreMessage, LanguageModelV1, generateText } from "ai";
-import { z } from "zod";
-
-export const describeZodSchema = (schema: z.ZodType): string => {
-  if (schema instanceof z.ZodObject) {
-    const entries = Object.entries(schema.shape);
-    const fields = entries.map(([key, value]) => {
-      const description = (value as any)._def.description || "";
-      const fieldSchema = describeZodSchema(value as z.ZodType);
-      return description
-        ? `${key}: ${fieldSchema} // ${description}`
-        : `${key}: ${fieldSchema}`;
-    });
-    return `z.object({${fields.join(", ")}})`;
-  }
-
-  if (schema instanceof z.ZodArray) {
-    return `z.array(${describeZodSchema(schema.element)})`;
-  }
-
-  if (schema instanceof z.ZodString) {
-    return "z.string()";
-  }
-
-  if (schema instanceof z.ZodNumber) {
-    return "z.number()";
-  }
-
-  if (schema instanceof z.ZodBoolean) {
-    return "z.boolean()";
-  }
-
-  if (schema instanceof z.ZodOptional) {
-    return `z.optional(${describeZodSchema(schema._def.innerType)})`;
-  }
-
-  if (schema instanceof z.ZodUnion) {
-    return `z.union([${schema._def.options
-      .map((option: z.ZodType) => describeZodSchema(option))
-      .join(", ")}])`;
-  }
-
-  if (schema instanceof z.ZodEnum) {
-    return `z.enum(${JSON.stringify(schema._def.values)})`;
-  }
-
-  if (schema instanceof z.ZodLiteral) {
-    return `z.literal(${JSON.stringify(schema._def.value)})`;
-  }
-
-  return "z.unknown()"; // Fallback for unknown types
-};
-
-export const generateObject = async <T>(config: {
-  model: LanguageModelV1;
-  schema: z.ZodSchema;
-  system: string;
-  temperature: number;
-  prompt?: string;
-  messages?: CoreMessage[];
-}): Promise<{ object: T }> => {
-  // Generate a detailed description of the schema
-  const schemaDescription = describeZodSchema(config.schema);
-
-  const baseContext = `
-  ${config.system}
-  EXPECTED SCHEMA:
-  ${schemaDescription}
-  
-  BAD EXAMPLE:
-  \`\`\`json
-  {
-    "key": "value"
-  }
-  \`\`\`
-
-  GOOD EXAMPLE:
-  {
-    "key": "value"
-  }
-
-  OUTPUT ONLY THE JSON SCHEMA, NO 'TRIPLE QUOTES'JSON OR ANY OTHER TEXT. ONLY THE JSON SCHEMA.
-  `;
-
-  console.log("🔍 Generating object with context:");
-  console.log(`${config.prompt}\n${baseContext}\n`);
-  const response = await generateText({
-    model: config.model,
-    messages: !config.prompt
-      ? [
-          {
-            role: "system",
-            content: baseContext,
-          },
-          ...(config.messages ?? []),
-        ]
-      : undefined,
-    system: config.system,
-    temperature: config.temperature,
-    prompt: !config.prompt ? undefined : `${config.prompt}\n\n${baseContext}`,
-  });
-
-  try {
-    // Clean the response text from any markdown or code block markers
-    const cleanText = response.text
-      .replace(/```json\s*/g, "")
-      .replace(/```\s*$/g, "")
-      .trim();
-
-    const parsedResponse = JSON.parse(cleanText);
-    const validatedResponse = config.schema.parse(parsedResponse);
-    return { object: validatedResponse as T };
-  } catch (error) {
-    console.error("Error parsing or validating JSON response:", error);
-    throw new Error("Failed to generate valid JSON response");
-  }
-};

package/utils/inject-actions.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import { ActionSchema } from "../types";
-
-export const injectActions = (actions: ActionSchema[]) => {
-  return actions.map((action) => {
-    const parameters = action.parameters as z.ZodObject<any>;
-    const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-    const actionString = `* ${action.name}( { ${schemaShape} }) (${
-      action.description
-    }) ${
-      action.examples
-        ? `Eg: ${action.examples.map((example: any) => {
-            return JSON.stringify(example);
-          })}`
-        : ""
-    }`;
-    return actionString;
-  });
-};

package/utils/queue-item-transformer.ts

@@ -1,38 +0,0 @@
-import { QueueItem, QueueItemParameter, QueueResult } from "@/types";
-
-export class QueueItemTransformer {
-  static transformActionToQueueItem(action: {
-    name: string;
-    parameters: Record<string, any>;
-  }): QueueItem {
-    return {
-      name: action.name || "",
-      parameters: QueueItemTransformer.transformParameters(
-        action.parameters || {}
-      ),
-    };
-  }
-
-  static transformFromSimilarActions(
-    similarActions: QueueResult[]
-  ): QueueItem[] | undefined {
-    return similarActions?.map((action: QueueResult) =>
-      QueueItemTransformer.transformActionToQueueItem(action)
-    );
-  }
-
-  private static transformParameters(
-    parameters: Record<string, any>
-  ): QueueItemParameter[] {
-    return Object.entries(parameters).map(([name, value]) => ({
-      name,
-      value: typeof value === "object" ? JSON.stringify(value) : String(value),
-    }));
-  }
-
-  static transformActionsToQueueItems(
-    actions: { name: string; parameters: Record<string, any> }[] | undefined
-  ): QueueItem[] | undefined {
-    return actions?.map((action) => this.transformActionToQueueItem(action));
-  }
-}

package/utils/sanitize-results.ts

@@ -1,66 +0,0 @@
-/**
- * Utility class to sanitize JSON results for evaluation
- */
-export class ResultSanitizer {
-  /**
-   * Sanitizes JSON results by removing special characters and formatting
-   * @param results - The results to sanitize
-   * @returns Sanitized string
-   */
-  static sanitize(results: any): string {
-    if (!results) return "";
-
-    try {
-      const jsonString = JSON.stringify(results);
-      return (
-        jsonString
-          // Basic cleanup
-          .replace(/\\n/g, " ") // Remove newlines
-          .replace(/\s+/g, " ") // Remove extra spaces
-          .replace(/\\"/g, '"') // Fix escaped quotes
-          .replace(/\\+/g, "") // Remove extra backslashes
-
-          // Remove unnecessary quotes around objects and arrays
-          .replace(/"\[/g, "[") // Remove quotes around arrays start
-          .replace(/\]"/g, "]") // Remove quotes around arrays end
-          .replace(/"{/g, "{") // Remove quotes around objects start
-          .replace(/}"/g, "}") // Remove quotes around objects end
-
-          // Clean up numbers and values
-          .replace(/"(\d+\.?\d*)"/g, "$1") // Remove quotes around numbers
-          .replace(/:\s*"(true|false|null)"/g, ": $1") // Remove quotes around booleans and null
-
-          // Clean up URLs and content
-          .replace(
-            /(?<=content":")([^"]+)(?=")/g,
-            (match) => match.trim().replace(/\s+/g, " ") // Clean content spacing
-          )
-          .replace(
-            /(?<=link":")([^"]+)(?=")/g,
-            (match) => match.replace(/&amp;/g, "&") // Fix URL encodings
-          )
-
-          // Final cleanup
-          .replace(/,\s*([}\]])/g, "$1") // Remove trailing commas
-          .replace(/:\s+/g, ":") // Remove spaces after colons
-          .replace(/,\s+/g, ",") // Remove spaces after commas
-          .trim()
-      ); // Remove leading/trailing whitespace
-    } catch (error) {
-      console.error("Error sanitizing results:", error);
-      return String(results);
-    }
-  }
-
-  /**
-   * Formats numbers to a consistent format
-   * @param value - The number to format
-   * @returns Formatted number string
-   */
-  private static formatNumber(value: number): string {
-    return value.toLocaleString("en-US", {
-      maximumFractionDigits: 2,
-      useGrouping: false,
-    });
-  }
-}