IntelliNode is a javascript module that integrates cutting-edge AI into your project. With its intuitive functions, you can easily feed data to models like GPT-5.5, Claude, Gemini, LLaMA, WaveNet and Stable diffusion and receive generated text, speech, or images. It also offers high-level functions such as semantic search, multi-model evaluation, and chatbot capabilities.

New in 3.0: a tool-calling loop and schema-matched JSON on every provider, a coding agent that fixes a repository until its tests pass, OpenAI-compatible services (OpenRouter, Groq, DeepSeek, Ollama), an MCP server for coding assistants (npx intellinode mcp) and TypeScript typings.

One command and get access to latest models:

npm i intellinode

For detailed usage instructions, refer to the documentation.

The Gen functions do a complete web-dev task in one line, with any provider.

import:

const { Gen } = require('intellinode');

call:

// React + Tailwind component source from a prompt (openai gpt-5.5 is default)
const code = await Gen.generate_component('a pricing card with a CTA button', openaiKey, 'openai', { styling: 'tailwind' });

// same call with Claude
const form = await Gen.generate_form('a contact form with name, email and message', anthropicKey, 'anthropic');

// API endpoint, SQL, mock data, regex, unit tests, code review, SEO meta, UI translation, ...
const endpoint = await Gen.generate_api_endpoint('POST /api/todos that creates a todo', openaiKey);
const regex = await Gen.generate_regex('a US phone number', openaiKey);   // { pattern, flags, regex, matches, nonMatches }
const meta = await Gen.generate_seo_meta('a product page for wireless headphones', openaiKey);
const spanish = await Gen.translate_ui_strings({ save: 'Save' }, openaiKey, 'openai', { targetLanguage: 'Spanish' });

// one line to generate html page code
text = 'a registration page with flat modern theme.'
await Gen.save_html_page(text, folder, file_name, openaiKey);

// or generate blog post (using cohere)
const blogPost = await Gen.get_blog_post(prompt, apiKey, provider='cohere');

The full list of Gen functions is in the package README.

import:

const { Chatbot, ChatGPTInput } = require('intellinode');

call GPT-5.5 (default):

// set chatGPT system mode and the user message.
const input = new ChatGPTInput('You are a helpful assistant.');
input.addUserMessage('What is the distance between the Earth and the Moon?');

// get chatGPT responses.
const chatbot = new Chatbot(OPENAI_API_KEY, 'openai');
const responses = await chatbot.chat(input);

stream the response (OpenAI, Anthropic, Mistral, Cohere, NVIDIA, vLLM and the OpenAI-compatible providers):

for await (const chunk of chatbot.stream(input)) {
  process.stdout.write(chunk);
}

run your tools until the model answers (any provider), or get schema-matched JSON with chatbot.chatJson(input):

const { text } = await chatbot.runTools(input, [{ name: 'get_weather', description: 'Weather for a city', parameters: { type: 'object', properties: { city: { type: 'string' } } }, handler: async ({ city }) => ({ city, tempC: 22 }) }]);

1. imports:

const { Chatbot, AnthropicInput, SupportedChatModels } = require('intellinode');

2. call (Claude Sonnet 5 is default; use claude-fable-5-1 for Fable or claude-opus-5 for Opus):

const input = new AnthropicInput('You are a helpful assistant.');
input.addUserMessage('Who painted the Mona Lisa?');

const claudeBot = new Chatbot(anthropicKey, SupportedChatModels.ANTHROPIC);
const responses = await claudeBot.chat(input);

IntelliNode enable effortless swapping between AI models.

1. imports:

const { Chatbot, GeminiInput, SupportedChatModels } = require('intellinode');

2. call:

const input = new GeminiInput();
input.addUserMessage('Who painted the Mona Lisa?');

const geminiBot = new Chatbot(apiKey, SupportedChatModels.GEMINI);
const responses = await geminiBot.chat(input);

OpenRouter, Groq, DeepSeek, xAI, Together and a local Ollama / LM Studio work with the same code:

const bot = new Chatbot(OPENROUTER_API_KEY, 'openrouter');   // or new Chatbot(null, 'ollama', null, { model: 'qwen3' })
const input = new OpenAICompatibleInput('You are a helpful assistant.', { model: 'anthropic/claude-sonnet-5' });

1. Import:

const { Chatbot, NvidiaInput, SupportedChatModels } = require("intellinode");

2. Call:

const input = new NvidiaInput("You are an insightful assistant.", {model: 'deepseek-ai/deepseek-v4-flash-0731'});
input.addUserMessage("What's the summary of the Inception movie?");

// visit build.nvidia.com to get your key.
const nvidiaBot = new Chatbot(NVIDIA_API_KEY, SupportedChatModels.NVIDIA);
const responses = await nvidiaBot.chat(input);

The documentation to switch the chatbot between ChatGPT, LLama, Cohere, Mistral and more can be found in the IntelliNode Wiki.

import:

const { SemanticSearch } = require('intellinode');

call:

const search = new SemanticSearch(apiKey);
// pivotItem is the item to search.
const results = await search.getTopMatches(pivotItem, searchArray, numberOfMatches);
const filteredArray = search.filterTopMatches(results, searchArray)

Generate improved prompts using LLMs:

const promptTemp = await Prompt.fromChatGPT("fantasy image with ninja jumping across buildings", openaiApiKey);
console.log(promptTemp.getInput());

import:

const { RemoteLanguageModel, LanguageModelInput } = require('intellinode');

call openai model:

const langModel = new RemoteLanguageModel('openai-key', 'openai');
model_name = 'gpt-3.5-turbo-instruct'

const results = await langModel.generateText(new LanguageModelInput({
  prompt: 'Write a product description for smart plug that works with voice assistant.',
  model: model_name,
  temperature: 0.7
}));

console.log('Generated text:', results[0]);

change to call cohere models:

const langModel = new RemoteLanguageModel('cohere-key', 'cohere');
model_name = 'command-a-03-2025'
// ... same code

import:

const { RemoteImageModel, SupportedImageModels, ImageModelInput } = require('intellinode');

call OpenAI (gpt-image-2 is default):

provider=SupportedImageModels.OPENAI;

const imgModel = new RemoteImageModel(apiKey, provider);
const images = await imgModel.generateImages(new ImageModelInput({
    prompt: 'teddy writing a blog in times square',
    numberOfImages: 1
}));

change to call Stable Diffusion:

provider=SupportedImageModels.STABILITY;
// ... same code

To access Openai services from your Azure account, you have to call the following function at the beginning of your application:

const { ProxyHelper } = require('intellinode');
ProxyHelper.getInstance().setAzureOpenai(resourceName);

To access Openai from a proxy for restricted regions:

ProxyHelper.getInstance().setOpenaiProxyValues(openaiProxyJson);

For more details and in-depth code, check the samples.

Give the agent a repository and a task; it edits, searches and runs commands inside the workspace until the test command passes, with any chat provider:

const agent = new CodingAgent({ apiKey: ANTHROPIC_API_KEY, provider: 'anthropic', workspace: './my_repo' });
const result = await agent.run('Fix the failing tests in calc.js', { testCommand: 'npm test' });

Give Claude Code, Cursor or VS Code the tools of every provider (ask a model, consensus, code review, fixes, tests, components, SQL, OpenAPI, mock data, images):

claude mcp add intellinode -e OPENAI_API_KEY=sk-... -e ANTHROPIC_API_KEY=sk-ant-... -- npx -y intellinode mcp

The library also ships an MCP client: pass new MCPClient({ command, args }) or new MCPClient({ url }) to chatbot.runTools. Details in MCP_IMPLEMENTATION.md.

Include the following CDN script in your HTML:

<script src="/api/v1/web-embed/proxy?proxyUrl=https%3A%2F%2Fcdn.jsdelivr.net%2Fnpm%2Fintellinode%40latest%2Ffront%2Fintellinode.min.js&mode=full"></script>

Check a sample html here.

1. Initiate the project:

cd IntelliNode
npm install

2. Create a .env file with the access keys:
   

OPENAI_API_KEY=<key_value>
COHERE_API_KEY=<key_value>
GOOGLE_API_KEY=<key_value>
STABILITY_API_KEY=<key_value>
HUGGING_API_KEY=<key_value>

1. run the remote language models test cases: node test/integration/RemoteLanguageModel.test.js

2. run the remote image models test cases: node test/integration/RemoteImageModel.test.js

3. run the remote speech models test cases: node test/integration/RemoteSpeechModel.test.js

4. run the embedding test cases: node test/integration/RemoteEmbedModel.test.js

5. run the chatBot test cases: node test/integration/Chatbot.test.js

6. run the latest provider features (GPT-5.5, Claude, Mistral, Cohere): node test/integration/ChatbotOpenAILatest.test.js node test/integration/ChatbotAnthropic.test.js node test/integration/ChatbotMistral.test.js node test/integration/CohereLatest.test.js

7. build and check the frontend bundle: npm run build && node test/integration/FrontBundle.test.js

8. run the offline unit tests: npm test

• IntelliNode Wiki: Check the wiki page for indepeth instructions and practical use cases.
• Showcase: Experience the potential of Intellinode in action, and use your keys to generate content and html pages.
• Samples: Explore a code sample with detailed setup documentation to get started with Intellinode.
• Model Evaluation: Demonstrate a swift approach to compare the performance of multiple models against designated target answers.
• Semantic Search: In-memory semantic search with iterator over large data.

The module foundation:

• The wrapper layer provides low-level access to the latest AI models
• The controller layer offers a unified input to any AI model by handling the differences. So you can switch between models like Openai and Cohere without changing the code.
• The function layer provides abstract functionality that extends based on the app's use cases. For example, an easy-to-use chatbot or marketing content generation utilities.

Call for contributors: registration form .

• Add support for vllm offline models.
• Add support for Nvidia Nim for local and remote models
• Evaluate multiple models using a few lines.
• Add Gen function to do complex business cases with one command.
• Add the tool-calling agent loop, structured output and OpenAI-compatible providers.
• Add the IntelliNode MCP server and a spec-current MCP client.
• Add multi-agent flows.

Apache License

Copyright 2023 Github.com/Barqawiz/IntelliNode

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.