Adding Luzmo IQ to your agentic workflow

import Luzmo from '@luzmo/nodejs-sdk';

const luzmoClient = new Luzmo({
  api_key: process.env.LUZMO_API_KEY!,
  api_token: process.env.LUZMO_API_TOKEN!,
  host: 'https://api.luzmo.com'
});

async function requestEmbedToken(
  userId: string,
  name: string,
  email: string,
  suborganization: string
): Promise<{ embedKey: string; embedToken: string }> {
  const response = await luzmoClient.create('authorization', {
    type: 'embed',
    username: userId,
    name,
    email,
    suborganization,
    access: {
      collections: [{ id: '<collection_id>', inheritRights: 'use' }],
      datasets: [{ id: '<dataset_id>', rights: 'use' }],
      dashboards: [{ id: '<dashboard_id>', rights: 'use' }]
    },
    iq: {
      context: `This is a master prompt you can use to steer Luzmo IQ in specific directions.

For example:
- Use a different response format (e.g. bullet points, tables)
- Add customer-specific details
- Enforce terminology
- Include confidence levels

These instructions apply to all IQMessage requests made with this token.`
    }
  });
  return { embedKey: response.id, embedToken: response.token };
}

async function handleIqMessage(
  prompt: string,
  embedKey: string,
  embedToken: string,
  response_mode: "mixed" | "text_only" | "chart_only" = "mixed",
  locale_id: string = "en"
): Promise<string> {
  const response = await fetch("https://api.luzmo.com/0.1.0/iqmessage", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      action: "create",
      version: "0.1.0",
      key: embedKey,
      token: embedToken,
      properties: { prompt, response_mode, locale_id }
    })
  });

  if (!response.ok) throw new Error(`IQMessage error: ${response.status}`);

  let result = "";
  const reader = response.body!.getReader();
  const decoder = new TextDecoder();
  let buffer = "";

  // Stream is JSONL: read until done; buffer handles lines split across chunks.
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? "";

    for (const line of lines) {
      try {
        const evt = JSON.parse(line.trim());
        if (evt.chunk) result += evt.chunk;
      } catch {
        // Ignore non-JSON lines (e.g. keepalive, empty or malformed).
      }
    }
  }

    return result || "(No data returned)";
}

import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const messages = [
  { role: "system", content: "You help users with data questions. Use data_analysis for analytics." },
  { role: "user", content: userQuestion }
];

const tools = [
  ..., // Your other tool definitions
  {
    type: "function",
    function: { name: "data_analysis", ... }, // See `data_analysis` schema above
  }
];

// Loop until the model responds without tool calls, or hit max rounds (safety cap).
for (let i = 0; i < 10; i++) {
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages,
    tools,
    tool_choice: "auto"
  });

  const choice = response.choices[0];

  // No tool calls means the model has the final answer; return it.
  if (!choice.message.tool_calls?.length) {
    return choice.message.content;
  }

  messages.push(choice.message);
  for (const tc of choice.message.tool_calls) {
    let result: string;
    if (tc.function.name === "data_analysis") {
      // First request a Luzmo Embed Authorization token for your end-user
      const { embedKey, embedToken } = await requestEmbedToken(
        currentUserId,
        currentUserName,
        currentUserEmail,
        currentUserSuborg
      );

      // Then send the prompt to the Luzmo IQ API to perform a data analysis
      const args = JSON.parse(tc.function.arguments);
      result = await handleIqMessage(
        args.prompt,
        embedKey,
        embedToken,
        args.response_mode ?? "mixed",
        args.locale_id ?? "en"
      );
    } else {
      // Handle other tools as needed
      result = `(Tool ${tc.function.name} not implemented in this example)`;
    }
    messages.push({ role: "tool", tool_call_id: tc.id, content: result });
  }
}

import { DynamicStructuredTool } from "@langchain/core/tools";
import { createAgent } from "langchain";
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const dataAnalysisTool = new DynamicStructuredTool({
  name: "data_analysis",
  description: "Query analytics data for metrics, KPIs, and business performance.",
  schema: z.object({
    prompt: z.string().describe("The data question to answer."),
    response_mode: z
      .enum(["mixed", "text_only", "chart_only"])
      .optional()
      .default("mixed")
      .describe("Response type: mixed (text and/or chart), text_only, or chart_only."),
    locale_id: z
      .string()
      .optional()
      .default("en")
      .describe("Locale/language for the answer (e.g. en, fr).")
  }),
  func: async ({ prompt, response_mode, locale_id }) => {
    const { embedKey, embedToken } = await requestEmbedToken(
      currentUserId,
      currentUserName,
      currentUserEmail,
      currentUserSuborg
    );
    return handleIqMessage(prompt, embedKey, embedToken, response_mode ?? "mixed", locale_id ?? "en");
  }
});

const llm = new ChatOpenAI({ model: "gpt-4o-mini" });
const agent = createAgent({
  model: llm,
  tools: [dataAnalysisTool],
  systemPrompt: "You help users with data questions. Use data_analysis for analytics."
});

const result = await agent.invoke({ messages: [{ role: "user", content: "What were last month's sales?" }] });
console.log(result.messages.at(-1)?.content);

import { tool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const dataAnalysis = tool(
  async ({ prompt, response_mode, locale_id }) => {
    const { embedKey, embedToken } = await requestEmbedToken(
      currentUserId,
      currentUserName,
      currentUserEmail,
      currentUserSuborg
    );
    return handleIqMessage(
      prompt,
      embedKey,
      embedToken,
      response_mode ?? "mixed",
      locale_id ?? "en"
    );
  },
  {
    name: "data_analysis",
    description: "Query analytics data for metrics, KPIs, and business performance.",
    schema: z.object({
      prompt: z.string().describe("The data question to answer."),
      response_mode: z
        .enum(["mixed", "text_only", "chart_only"])
        .optional()
        .default("mixed")
        .describe("Response type: mixed (text and/or chart), text_only, or chart_only."),
      locale_id: z
        .string()
        .optional()
        .default("en")
        .describe("Locale/language for the answer (e.g. en, fr).")
    })
  }
);

const llm = new ChatOpenAI({ model: "gpt-4o-mini" });
const agent = createReactAgent({ llm, tools: [dataAnalysis] });

const result = await agent.invoke({
  messages: [{ role: "user", content: "What were last month's sales?" }]
});

import * as z from "zod";
import { createDeepAgent } from "deepagents";
import { tool } from "langchain";

const dataAnalysis = tool(
  async ({ prompt, response_mode, locale_id }) => {
    const { embedKey, embedToken } = await requestEmbedToken(
      currentUserId,
      currentUserName,
      currentUserEmail,
      currentUserSuborg
    );
    return handleIqMessage(
      prompt,
      embedKey,
      embedToken,
      response_mode ?? "mixed",
      locale_id ?? "en"
    );
  },
  {
    name: "data_analysis",
    description: "Query analytics data for metrics, KPIs, and business performance.",
    schema: z.object({
      prompt: z.string().describe("The data question to answer."),
      response_mode: z
        .enum(["mixed", "text_only", "chart_only"])
        .optional()
        .default("mixed")
        .describe("Response type: mixed (text and/or chart), text_only, or chart_only."),
      locale_id: z
        .string()
        .optional()
        .default("en")
        .describe("Locale/language for the answer (e.g. en, fr).")
    })
  }
);

const agent = createDeepAgent({
  tools: [dataAnalysis],
  system: "You help users with data questions. Use data_analysis for analytics.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "What were last month's sales?" }]
});