Empowering AI: The QuickJS Package for LLM Tool Calling

As AI continues to evolve, the ability to safely execute code becomes increasingly important. The QuickJS package is perfectly positioned to fill this gap, offering a powerful solution for implementing tool calling capabilities in AI applications.

Why QuickJS for AI Tool Calling?

When developing AI systems that interact with user-provided or dynamically generated code, security is paramount. The QuickJS package provides a secure sandbox that allows LLMs to execute JavaScript code safely, opening up a world of possibilities for AI-powered tools and applications.

Key Benefits for AI Developers:

1. Secure Execution: Run AI-generated or user-provided JavaScript code without risking your main application or server.
2. Flexible Integration: Easily integrate with various LLM frameworks and AI platforms.
3. Rich Environment: Provide a Node.js-like environment for more complex tool implementations.
4. Performance: Leverage the speed of QuickJS for quick code execution in AI workflows.
5. Customizable Sandbox: Control what capabilities are available to the AI, ensuring safe and appropriate tool use.

Example: Implementing an AI Code Executor with LangChain

Here's an example of how you can use the QuickJS package with LangChain to create a powerful AI code execution tool:

import { ChatOpenAI } from "@langchain/openai";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { quickJS } from '@sebastianwessel/quickjs';
import { z } from "zod";

// Initialize QuickJS (this should be done once)
const initQuickJS = async () => {
  const { createRuntime } = await quickJS();
  return createRuntime({
    allowFetch: false,  // Disable network access for safety
    allowFs: true,      // Allow file system operations if needed
    env: {
      AI_VERSION: '1.0',
    },
  });
};

// Create a QuickJS runtime
const quickJSRuntime = await initQuickJS();

// Define the schema for our JavaScript execution tool
const jsExecutionSchema = z.object({
  code: z.string().describe("The JavaScript code to execute"),
});

// Create the JavaScript execution tool
const jsExecutionTool = new DynamicStructuredTool({
  name: "javascript_executor",
  description: "Executes JavaScript code and returns the result.",
  schema: jsExecutionSchema,
  func: async ({ code }) => {
    try {
      const { evalCode } = await quickJSRuntime;
      const result = await evalCode(code);
      return JSON.stringify(result);
    } catch (error) {
      return `Error executing code: ${error.message}`;
    }
  },
});

// Initialize the language model with the tool
const model = new ChatOpenAI({
  modelName: "gpt-3.5-turbo",
  temperature: 0,
});
const llmWithTools = model.bind({
  tools: [jsExecutionTool],
});

// Example usage
const query = "Calculate the 10th Fibonacci number using JavaScript.";
const result = await llmWithTools.invoke(query);

console.log("AI Response:", result.content);
console.log("Tool Calls:", result.additional_kwargs.tool_calls);

// If there's a tool call, we can execute it
if (result.additional_kwargs.tool_calls) {
  const toolCall = result.additional_kwargs.tool_calls[0];
  const toolResult = await jsExecutionTool.call(
    JSON.parse(toolCall.function.arguments)
  );
  console.log("Tool Execution Result:", toolResult);
}

This setup allows the AI to write and execute JavaScript code safely within the QuickJS sandbox, providing a powerful and flexible tool for various tasks. It combines the strengths of LangChain for AI interactions with the security and flexibility of the QuickJS package for code execution.

Enhancing AI Capabilities

By integrating the QuickJS package into your AI toolkit, you can:

1. Implement Complex Tools: Allow your AI to write and execute more sophisticated tools on the fly.
2. Safe Code Testing: Let AI assistants test and debug code in a controlled environment.
3. Dynamic Data Processing: Enable AI to process data using custom JavaScript functions.
4. Interactive Coding Tutorials: Create AI-powered coding education platforms with live code execution.
5. Secure Serverless Functions: Implement AI-generated serverless functions with built-in security.

---

Documentation: https://sebastianwessel.github.io/quickjs/
GitHub Repository: https://github.com/sebastianwessel/quickjs
Submit Feedback: Create an Issue on GitHub