illuma-agents 1.0.2

package/src/proto/example_new.ts

@@ -0,0 +1,68 @@
+import dotenv from 'dotenv';
+import { ToolNode } from '@langchain/langgraph/prebuilt';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { AIMessage, BaseMessage } from '@langchain/core/messages';
+import { SqliteSaver } from '@langchain/langgraph/checkpoint/sqlite';
+import { START, END, MessageGraph } from '@langchain/langgraph';
+dotenv.config();
+
+// Define the function that determines whether to continue or not
+/* @ts-ignore */
+function shouldContinue(messages) {
+    const lastMessage = messages[messages.length - 1];
+    // If there is no function call, then we finish
+    if (!(lastMessage instanceof AIMessage && lastMessage.tool_calls)) {
+        return END;
+    } else {
+        return 'action';
+    }
+}
+
+// Define tools and model
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+const model = new ChatAnthropic({ model: 'claude-3-haiku-20240307' }).bindTools(tools);
+
+// Define the workflow
+const workflow = new MessageGraph()
+    .addNode('agent', model)
+/* @ts-ignore */
+    .addNode('action', new ToolNode(tools));
+
+workflow.addEdge(START, 'agent');
+workflow.addConditionalEdges('agent', shouldContinue);
+workflow.addEdge('action', 'agent');
+
+// Set up memory
+const memory = SqliteSaver.fromConnString(':memory:');
+
+// Compile the app
+const app = workflow.compile({ checkpointer: memory, interruptBefore: ['action'] });
+
+// Run the graph
+async function runGraph() {
+    const thread = { configurable: { thread_id: '4' } };
+
+    console.log('Initial run:');
+    for await (const event of await app.stream(
+        [['user', 'what is the weather in sf currently']],
+        { ...thread, streamMode: 'values' }
+    )) {
+        for (const v of event.values()) {
+            console.log(v);
+        }
+    }
+
+    console.log('\nResuming after interruption:');
+    for await (const event of await app.stream(null, {
+        ...thread,
+        streamMode: 'values',
+    })) {
+        for (const v of event.values()) {
+            console.log(v);
+        }
+    }
+}
+
+// Execute the graph
+runGraph().catch(console.error);

package/src/proto/example_old.ts

@@ -0,0 +1,201 @@
+import fs from 'fs/promises';
+import { pull } from 'langchain/hub';
+import { ChatAnthropic } from '@langchain/anthropic';
+import type { ChatPromptTemplate } from '@langchain/core/prompts';
+import { AgentExecutor, createToolCallingAgent, AgentStep } from 'langchain/agents';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import type { RunLogPatch } from '@langchain/core/tracers/log_stream';
+import dotenv from 'dotenv';
+
+type ExtractedJSONPatchOperation = Pick<RunLogPatch, 'ops'>;
+type OperationType = ExtractedJSONPatchOperation extends { ops: (infer T)[] } ? T : never;
+
+// Load environment variables from .env file
+dotenv.config();
+
+// Define the tools the agent will have access to.
+const tools = [new TavilySearchResults({})];
+
+const llm = new ChatAnthropic({
+    model: 'claude-3-haiku-20240307',
+    streaming: true,
+});
+
+// Get the prompt to use - you can modify this!
+// If you want to see the prompt in full, you can at:
+// https://smith.langchain.com/hub/hwchase17/openai-functions-agent
+const prompt = await pull<ChatPromptTemplate>(
+    'hwchase17/openai-functions-agent'
+);
+
+const agent = await createToolCallingAgent({
+    llm,
+    tools,
+    prompt,
+});
+
+const agentExecutor = new AgentExecutor({
+    agent,
+    tools,
+});
+
+const logStream = await agentExecutor.streamLog({
+    input: 'what are the current US election polls 2024. today is 7/6/24',
+});
+
+const finalState: RunLogPatch[] = [];
+const outputs: RunLogPatch[] = [];
+let accumulatedOutput = '';
+let accumulatedArguments = '';
+
+let functionName: string | undefined = undefined;
+
+function processStreamedOutput(op: any) {
+    let output = '';
+    if (op.value.text !== undefined) {
+        output += op.value.text;
+    }
+    if (op.value.message && op.value.message.kwargs) {
+        const kwargs = op.value.message.kwargs;
+        if (kwargs.content) {
+            output += kwargs.content;
+        }
+    }
+    if (output) {
+        accumulatedOutput += output;
+        process.stdout.write(output);
+    }
+}
+
+// A helper function to handle the event pattern for logged arguments
+function handleLoggedArgument(loggedArgument: any) {
+    if (loggedArgument.value?.message?.additional_kwargs?.function_call) {
+        const functionCall = loggedArgument.value.message.additional_kwargs.function_call;
+
+        if (functionCall.name) {
+            functionName = functionCall.name;
+            process.stdout.write(`Logged Function Name:
+        ${JSON.stringify(functionCall, null, 2)}
+      `);
+        }
+
+        if (functionCall.arguments) {
+            accumulatedArguments += functionCall.arguments;
+            // Print the part of the argument as it comes
+            // process.stdout.write(`Logged Argument: { "arguments": "${functionCall.arguments}" }\n`);
+            process.stdout.write(`Logged Argument:\n${JSON.stringify(functionCall, null, 2)}`);
+        }
+
+        // Check if the full arguments string has been accumulated
+        if (accumulatedArguments.startsWith('{') && accumulatedArguments.endsWith('}')) {
+            // Build the final logged argument string
+            const completeArguments = accumulatedArguments;
+            const namePart = functionName ? `"name": "${functionName}", ` : '';
+
+            console.log(`\nLogged Argument: {\n  ${namePart}"arguments": ${completeArguments}\n}\n`);
+
+            // Reset accumulators
+            accumulatedArguments = '';
+            functionName = undefined;
+        }
+    }
+}
+
+for await (const chunk of logStream) {
+    finalState.push(chunk);
+    outputs.push(chunk);
+
+    if (!chunk.ops) continue;
+
+    for (const op of chunk.ops) {
+        if (isStreamedOutput(op)) {
+            processStreamedOutput(op);
+            if (hasFunctionCall(op)) {
+                handleLoggedArgument(op);
+            }
+        } else if (isFinalOutput(op)) {
+            printFinalOutput(op);
+        }
+    }
+}
+
+function isStreamedOutput(op: OperationType) {
+    return op.op === 'add' && (
+        op.path.includes('/streamed_output/-') ||
+    op.path.includes('/streamed_output_str/-')
+    );
+}
+
+function hasFunctionCall(op: OperationType) {
+    return (op as any)?.['value']?.message?.additional_kwargs?.function_call;
+}
+
+function isFinalOutput(op: OperationType) {
+    return op.op === 'add' &&
+         op.value?.output &&
+         op.path?.startsWith('/logs/') &&
+         op.path?.endsWith('final_output') &&
+         !op.path?.includes('Runnable');
+}
+
+function printFinalOutput(op: OperationType) {
+    process.stdout.write(JSON.stringify(op, null, 2));
+    process.stdout.write(`
+
+########################_START_##########################
+        ${JSON.stringify((op as any)?.['value']?.output, null, 2)}
+########################__END__##########################
+
+        `);
+}
+
+// Define types for the final output structure
+interface FinalOutput {
+  id: string;
+  streamed_output: Array<{
+    intermediateSteps?: AgentStep[];
+    output?: string;
+  }>;
+  final_output?: {
+    output: string;
+  };
+  logs: Record<string, any>;
+}
+
+// Process finalState to create FinalOutput
+const finalOutput: FinalOutput = {
+    id: '',
+    streamed_output: [],
+    logs: {},
+};
+
+for (const patch of finalState) {
+    if (patch.ops) {
+        for (const op of patch.ops) {
+            if (op.op === 'add' || op.op === 'replace') {
+                if (op.path === '/id') {
+                    finalOutput.id = op.value;
+                } else if (op.path === '/streamed_output/-') {
+                    finalOutput.streamed_output.push(op.value);
+                } else if (op.path === '/final_output') {
+                    finalOutput.final_output = op.value;
+                } else if (op.path.startsWith('/logs/')) {
+                    const logKey = op.path.split('/')[2];
+                    finalOutput.logs[logKey] = op.value;
+                }
+            }
+        }
+    }
+}
+
+// Save outputs to a JSON file
+await fs.writeFile('outputs.json', JSON.stringify(outputs, null, 2));
+console.log('\n\nOutputs have been saved to outputs.json');
+
+// Save the final state separately
+await fs.writeFile('final_output.json', JSON.stringify(finalOutput, null, 2));
+console.log('\n\nFinal output has been saved to final_output.json');
+
+// Save the cleaned-up accumulated output
+await fs.writeFile('cleaned_output.txt', accumulatedOutput);
+console.log('\n\nCleaned output has been saved to cleaned_output.txt');

package/src/proto/example_test.ts

@@ -0,0 +1,152 @@
+import { BaseMessage, HumanMessage } from "@langchain/core/messages";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import { RunnableConfig } from "@langchain/core/runnables";
+import {
+  END,
+  // MemorySaver,
+  START,
+  StateGraph,
+  StateGraphArgs,
+} from "@langchain/langgraph";
+
+interface IState {
+  messages: BaseMessage[];
+  userInfo: string;
+}
+
+async function main() {
+
+const graphState: StateGraphArgs<IState>["channels"] = {
+  messages: {
+    value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
+    default: () => [],
+  },
+  userInfo: {
+    value: (x?: string, y?: string) => {
+      return y ? y : x ? x : "N/A";
+    },
+    default: () => "N/A",
+  },
+};
+
+const promptTemplate = ChatPromptTemplate.fromMessages([
+  ["system", "You are a helpful assistant.\n\n## User Info:\n{userInfo}"],
+  ["placeholder", "{messages}"],
+]);
+
+const initializeModel = (bindTools = false) => {
+  const model = new ChatAnthropic({
+    // model: "claude-3-haiku-20240307",
+    model: 'claude-3-5-sonnet-20240620'
+  })
+  if (bindTools) {
+    return model.bindTools([new TavilySearchResults()]);
+  }
+  return model;
+}
+
+const callModel = async (
+  state: { messages: BaseMessage[]; userInfo: string },
+  config?: RunnableConfig,
+) => {
+  const { messages, userInfo } = state;
+  
+  /*
+
+  This correctly streams tokens when 
+  we don't bind tools, but if we do, it fails.
+
+  */
+  const model = initializeModel(true);
+  // const model = initializeModel();
+  const chain = promptTemplate.pipe(model);
+  const response = await chain.invoke(
+    {
+      messages,
+      userInfo,
+    },
+    config,
+  );
+  return { messages: [response] };
+};
+
+const fetchUserInformation = async (
+  _: { messages: BaseMessage[] },
+  config?: RunnableConfig,
+) => {
+  const userDB = {
+    user1: {
+      name: "John Doe",
+      email: "jod@langchain.ai",
+      phone: "+1234567890",
+    },
+    user2: {
+      name: "Jane Doe",
+      email: "jad@langchain.ai",
+      phone: "+0987654321",
+    },
+  };
+  const userId = config?.configurable?.user;
+  if (userId) {
+    const user = userDB[userId as keyof typeof userDB];
+    if (user) {
+      return {
+        userInfo:
+          `Name: ${user.name}\nEmail: ${user.email}\nPhone: ${user.phone}`,
+      };
+    }
+  }
+  return { userInfo: "N/A" };
+};
+
+const workflow = new StateGraph({
+  channels: graphState,
+})
+  .addNode("fetchUserInfo", fetchUserInformation)
+  .addNode("agent", callModel)
+  .addEdge(START, "fetchUserInfo")
+  .addEdge("fetchUserInfo", "agent")
+  .addEdge("agent", END);
+
+// Here we only save in-memory
+// let memory = new MemorySaver();
+// const graph = workflow.compile({ checkpointer: memory });
+const graph = workflow.compile();
+
+
+const config = {
+  configurable: {
+    user: "user1",
+  },
+};
+const inputs = {
+  messages: [new HumanMessage("Could you remind me of my email?")],
+};
+
+  const stream = graph.streamEvents(inputs, {
+    ...config,
+    version: "v2",
+    streamMode: "values",
+  });
+for await (const { event, data } of stream) {
+
+  if (event === "on_chat_model_start") {
+    console.log('=======CHAT_MODEL_START=======');
+    console.dir(data, { depth: null });
+  } else if (event === "on_chat_model_stream") {
+    console.dir(data, { depth: null });
+  } else if (event === "on_chat_model_end") {
+    console.log('=======CHAT_MODEL_END=======');
+    console.dir(data, { depth: null });
+  } else {
+    console.log(event);
+  }
+}
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/proto/example_test_anthropic.ts

@@ -0,0 +1,100 @@
+import { BaseMessage, HumanMessage, AIMessageChunk, AIMessage } from "@langchain/core/messages";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import { RunnableConfig } from "@langchain/core/runnables";
+import { ToolNode } from '@langchain/langgraph/prebuilt';
+import {
+  END,
+  START,
+  StateGraph,
+  StateGraphArgs,
+} from "@langchain/langgraph";
+
+interface IState {
+  messages: BaseMessage[];
+}
+
+async function main() {
+  const graphState: StateGraphArgs<IState>["channels"] = {
+    messages: {
+      value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
+      default: () => [],
+    },
+  };
+
+  const promptTemplate = ChatPromptTemplate.fromMessages([
+    ["system", "You are a helpful assistant."],
+    ["placeholder", "{messages}"],
+  ]);
+
+  const initializeModel = (bindTools = false) => {
+    const model = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20240620'
+    })
+    if (bindTools) {
+      return model.bindTools([new TavilySearchResults()]);
+    }
+    return model;
+  }
+  
+  const callModel = async (
+    state: { messages: BaseMessage[] },
+    config?: RunnableConfig,
+  ) => {
+    const { messages } = state;
+    
+    const model = initializeModel(true);
+    const chain = promptTemplate.pipe(model);
+    const response = await chain.invoke(
+      {
+        messages,
+      },
+      config,
+    );
+    return { messages: [response] };
+  };
+
+  const tools = [new TavilySearchResults()];
+  const toolNode = new ToolNode<IState>(tools);
+
+  const routeMessage = (state: IState): string => {
+    const lastMessage = state.messages[state.messages.length - 1] as AIMessage;
+    if (!lastMessage?.tool_calls?.length) {
+      return END;
+    }
+    return "tools";
+  };
+
+  const workflow = new StateGraph({
+    channels: graphState,
+  })
+    .addNode("agent", callModel)
+    .addNode("tools", toolNode)
+    .addEdge(START, "agent")
+    .addConditionalEdges("agent", routeMessage)
+    .addEdge("tools", "agent");
+
+  const graph = workflow.compile();
+
+  const inputs = {
+    messages: [new HumanMessage("Could you search the internet for information about LangChain?")],
+  };
+
+  const stream = graph.streamEvents(inputs, {
+    version: "v2",
+    streamMode: "values",
+  });
+
+  for await (const { event, data } of stream) {
+    console.log(event)
+    if (event === "on_chat_model_stream") {
+      console.log(data);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});