intellinode
Access the latest AI models like ChatGPT, Fable, Deepseek, Diffusion, Hugging face, and beyond through a unified prompt layer and performance evaluation
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/intelligentnode--intellinode)HTML
<a href="/listings/intelligentnode--intellinode"><img src="/api/listings/intelligentnode--intellinode/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
One command and get access to latest models:
npm i intellinode
For detailed usage instructions, refer to the [documentation](https://www.intellinode.ai/docs/npm).
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
.claude-plugin/marketplace.json · Manifest · 21 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- {
- "name": "intellinode-js",
- "owner": {
- "name": "IntelliNode"
- },
- "metadata": {
- "description": "Claude Code plugins for building AI apps in JavaScript and TypeScript with IntelliNode."
- },
- "plugins": [
- {
- "name": "intellinode",
- "source": "./plugins/intellinode",
- "description": "Build Gemini- and ChatGPT-style apps, assistants with memory, RAG over vector databases and multi-provider AI features in JavaScript with the IntelliNode library, plus an MCP server with cross-provider tools.",
- "homepage": "https://www.intellinode.ai",
- "repository": "https://github.com/intelligentnode/IntelliNode",
- "license": "Apache-2.0",
- "keywords": ["intellinode", "javascript", "nodejs", "gemini", "vertex-ai", "rag", "vector-database", "assistant", "mcp"],
- "category": "development"
- }
- ]
- }
README.md · README · 408 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- <!-- <p align="center">
- <img src="images/intellinode_new_header.png" width="400em">
- </p> -->
- <p align="center">
- <img src="images/multimodel-banner.png" width="650em">
- </p>
- <h3 align="center">
- Unified prompt, evaluation, and production integration to any large model
- </h3>
- <p align="center">
- <a href="https://www.npmjs.com/package/intellinode" alt="npm version">
- <img src="https://img.shields.io/npm/v/intellinode?style=flat-square" />
- </a>
- <a href="https://www.jsdelivr.com/package/npm/intellinode" alt="licenses tag">
- <img src="https://data.jsdelivr.com/v1/package/npm/intellinode/badge" />
- </a>
- <a href="https://opensource.org/licenses/Apache-2.0" alt="licenses tag">
- <img src="https://img.shields.io/github/license/intelligentnode/IntelliNode?style=flat-square" />
- </a>
- <a href="https://discord.gg/VYgCh2p3Ww" alt="Join our Discord community">
- <img src="https://img.shields.io/badge/Discord-join%20us-5865F2?style=flat-square&logo=discord&logoColor=white" />
- </a>
- </p>
- # Intelligent Node
- 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.1: every Gemini feature on the Gemini Developer API and Vertex AI (Google Search grounding, images, Veo video, Lyria music, speech, the Live API), an `Assistant` for Gemini- and ChatGPT-style apps with saved conversations, document answers with sources and long-term memory, vector stores for Google Cloud (Firestore, RAG Engine, Vector Search), Pinecone, Qdrant, Chroma, Weaviate, Milvus, Elasticsearch, pgvector and MongoDB Atlas, and an agent skill for Claude Code and Codex.
- 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.
- # Access the module
- ## Install
- One command and get access to latest models:
- ```
- npm i intellinode
- ```
- For detailed usage instructions, refer to the [documentation](https://www.intellinode.ai/docs/npm).
- ## Examples
- ### Gen
- The `Gen` functions do a complete web-dev task in one line, with any provider.<br><br>
- import:
- ```js
- const { Gen } = require('intellinode');
- ```
- call:
- ```js
- // 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' });
- ```
- ```js
- // same call with Claude
- const form = await Gen.generate_form('a contact form with name, email and message', anthropicKey, 'anthropic');
- ```
- ```js
- // 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' });
- ```
- ```js
- // 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);
- ```
- ```js
- // 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](IntelliNode/README.md#gen).
- ### Chatbot
- import:
- ```js
- const { Chatbot, ChatGPTInput } = require('intellinode');
- ```
- call GPT-5.5 (default):
- ```js
- // 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, Gemini, Vertex AI, Mistral, Cohere, NVIDIA, vLLM and the OpenAI-compatible providers):
- ```js
- 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)`:
- ```js
- 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 }) }]);
- ```
- ### Anthropic Claude Chatbot
- 1. imports:
- ```js
- 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):
- ```js
- 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);
- ```
- ### Gemini and Vertex AI Chatbot
- 1. imports:
- ```js
- const { Chatbot, GeminiInput } = require('intellinode');
- ```
- 2. call the Gemini Developer API, or Vertex AI with the `vertex` provider (an Agent Platform key runs in express mode; add `{ projectId }` for project mode):
- ```js
- const input = new GeminiInput('You are a helpful assistant.', { systemInstruction: true });
- input.addUserMessage('Who painted the Mona Lisa?');
- const geminiBot = new Chatbot(geminiApiKey, 'gemini'); // or new Chatbot(vertexApiKey, 'vertex')
- const responses = await geminiBot.chat(input);
- ```
- ### Assistant: Gemini- and ChatGPT-style apps
- Saved conversations, answers grounded on your documents with numbered sources, long-term memory, attachments, Google Search and streaming, on any provider:
- ```js
- const { Assistant, FirestoreChatHistory, FirestoreVectorStore, MemoryVectorStore } = require('intellinode');
- const embedder = { provider: 'vertex', apiKey: VERTEX_API_KEY, dimensions: 768 };
- const assistant = new Assistant({
- provider: 'vertex', apiKey: VERTEX_API_KEY,
- history: new FirestoreChatHistory({ projectId }), // conversations in Firestore
- memory: new FirestoreVectorStore({ projectId, collection: 'memories', embedder }), // recalled in later chats
- knowledge: new MemoryVectorStore({ embedder }), // your documents
- });
- await assistant.addDocuments([{ id: 'handbook.md', text: handbookText }]);
- const reply = await assistant.chat('When does the on-call rotation change?', { userId: 'u1' });
- // { conversationId, text, references, citations, memories, usage }; assistant.stream(...) yields the same live
- ```
- Try the local chat app template: [IntelliNode/skills/intellinode/assets/chat-app](IntelliNode/skills/intellinode/assets/chat-app).
- ### Vector stores
- One interface (`addDocuments`, `search`, `query`, `upsert`, `delete`) for Firestore, Vertex AI RAG Engine, Vertex AI Vector Search, Pinecone, Qdrant, Chroma, Weaviate, Milvus, Elasticsearch, pgvector (AlloyDB, Cloud SQL, Supabase, Neon), MongoDB Atlas and an in-memory store, with embeddings from any provider:
- ```js
- const store = new QdrantVectorStore({ url: 'http://localhost:6333', collection: 'docs', embedder: { provider: 'openai', apiKey: OPENAI_API_KEY } });
- await store.addDocuments([{ id: 'a', text: 'IntelliNode supports Gemini.' }]);
- const hits = await store.search('Which models are supported?', 3); // [{ id, score, text, metadata }]
- ```
- ### OpenAI-compatible providers
- OpenRouter, Groq, DeepSeek, xAI, Together and a local Ollama / LM Studio work with the same code:
- ```js
- 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' });
- ```
- ### Nvidia DeepSeek
- 1. Import:
- ```js
- const { Chatbot, NvidiaInput, SupportedChatModels } = require("intellinode");
- ```
- 2. Call:
- ```js
- 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](https://github.com/Barqawiz/IntelliNode/wiki/ChatBot).
- ### Semantic search
- import:
- ```js
- const { SemanticSearch } = require('intellinode');
- ```
- call:
- ```js
- 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)
- ```
- ### Prompt engineering
- Generate improved prompts using LLMs:
- ```js
- const promptTemp = await Prompt.fromChatGPT("fantasy image with ninja jumping across buildings", openaiApiKey);
- console.log(promptTemp.getInput());
- ```
- ### Language models
- import:
- ```js
- const { RemoteLanguageModel, LanguageModelInput } = require('intellinode');
- ```
- call openai model:
- ```js
- 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:
- ```js
- const langModel = new RemoteLanguageModel('cohere-key', 'cohere');
- model_name = 'command-a-03-2025'
- // ... same code
- ```
- ### Image models
- import:
- ```js
- const { RemoteImageModel, SupportedImageModels, ImageModelInput } = require('intellinode');
- ```
- call OpenAI (gpt-image-2 is default):
- ```js
- 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:
- ```js
- provider=SupportedImageModels.STABILITY;
- // ... same code
- ```
- ### Openai advanced access
- To access Openai services from your Azure account, you have to call the following function at the beginning of your application:
- ```js
- const { ProxyHelper } = require('intellinode');
- ProxyHelper.getInstance().setAzureOpenai(resourceName);
- ```
- To access Openai from a proxy for restricted regions:
- ```js
- ProxyHelper.getInstance().setOpenaiProxyValues(openaiProxyJson);
- ```
- For more details and in-depth code, check [the samples](https://github.com/Barqawiz/IntelliNode/tree/main/samples/command_sample).
- # Coding agent
- 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:
- ```js
- 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' });
- ```
- # Agent skill for Claude Code and Codex
- Teach your coding agent to build with IntelliNode (assistants, RAG, vector stores, Gemini and Vertex AI, MCP):
- ```
- npx intellinode skill install
- ```
- Or add this repository as a plugin marketplace, which also installs the MCP server:
- ```
- claude plugin marketplace add intelligentnode/IntelliNode
- claude plugin install intellinode@intellinode-js
- codex plugin marketplace add intelligentnode/IntelliNode
- ```
- # MCP server for coding assistants
- Give Claude Code, Codex, Cursor or VS Code the tools of every provider (ask a model, consensus, web search with sources, code review, fixes, tests, components, SQL, OpenAPI, mock data, images, speech):
- ```
- claude mcp add intellinode -e OPENAI_API_KEY=sk-... -e ANTHROPIC_API_KEY=sk-ant-... -- npx -y intellinode mcp
- codex mcp add intellinode --env GEMINI_API_KEY=... -- 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](IntelliNode/MCP_IMPLEMENTATION.md).
- # Frontend
- Include the following CDN script in your HTML:
- ```
- <script src="https://cdn.jsdelivr.net/npm/intellinode@latest/front/intellinode.min.js"></script>
- ```
- Check a sample html [here](https://github.com/Barqawiz/IntelliNode/tree/main/samples/frontend).
- # The code repository setup
- ## First setup
- 1. Initiate the project:
- ```
- cd IntelliNode
- npm install
- ```
- 2. Create a .env file with the access keys:<br>
- ```
- OPENAI_API_KEY=<key_value>
- COHERE_API_KEY=<key_value>
- GOOGLE_API_KEY=<key_value>
- GEMINI_API_KEY=<key_value>
- VERTEX_API_KEY=<key_value>
- VERTEX_PROJECT_ID=<project_id>
- STABILITY_API_KEY=<key_value>
- HUGGING_API_KEY=<key_value>
- ```
- ## Test cases
- 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. run the Gemini and Vertex AI live checks (the Live API needs Node 22+, or `--experimental-websocket` on Node 20):
- `node --experimental-websocket test/integration/GoogleGenAI.test.js`
- 8. run the vector store checks against your own databases (each store runs when its URL or key is set):
- `node test/integration/VectorStores.test.js`
- 9. build and check the frontend bundle:
- `npm run build && node test/integration/FrontBundle.test.js`
- 10. run the offline unit tests:
- `npm test`
- # :closed_book: Documentation
- - [IntelliNode Wiki](https://github.com/Barqawiz/IntelliNode/wiki): Check the wiki page for indepeth instructions and practical use cases.
- - [Showcase](https://show.intellinode.ai/): Experience the potential of Intellinode in action, and use your keys to generate content and html pages.
- - [Samples](https://github.com/Barqawiz/IntelliNode/tree/main/samples/command_sample): Explore a code sample with detailed setup documentation to get started with Intellinode.
- - [Model Evaluation](https://www.intellinode.ai/articles/automate-evaluating-language-models): Demonstrate a swift approach to compare the performance of multiple models against designated target answers.
- - [Semantic Search](https://github.com/intelligentnode/IntelliNode/wiki/Semantic-Search): In-memory semantic search with iterator over large data.
- # Pillars
- 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.
- # Roadmap
- Call for contributors:
- [registration form ](https://forms.gle/2JsEHAMaj2eMQHYc9).
- - [x] Add support for vllm offline models.
- - [x] Add support for Nvidia Nim for local and remote models
- - [x] Evaluate multiple models using a few lines.
- - [x] Add Gen function to do complex business cases with one command.
- - [x] Add the tool-calling agent loop, structured output and OpenAI-compatible providers.
- - [x] Add the IntelliNode MCP server and a spec-current MCP client.
- - [x] Add every Gemini and Vertex AI feature, the Assistant, vector stores and the Claude Code / Codex skill.
- - [ ] Add multi-agent flows.
- # License
- 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.
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.