Empowering AI: The QuickJS Package for LLM Tool Calling
Tags: ai, rag, javascript, typescript
Published: 2024-07-07 13:23:36

As AI continues to evolve, the ability to safely execute code becomes increasingly important. The [QuickJS package](https://sebastianwessel.github.io/quickjs/) 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](https://sebastianwessel.github.io/quickjs/) 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](https://js.langchain.com/v0.1/docs/get_started/installation/)

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

```typescript
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 ](https://sebastianwessel.github.io/quickjs/)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/](https://sebastianwessel.github.io/quickjs/)
GitHub Repository: [https://github.com/sebastianwessel/quickjs](https://github.com/sebastianwessel/quickjs)
Submit Feedback: [Create an Issue on GitHub](https://github.com/sebastianwessel/quickjs/issues)