Intelli
A framework for creating chatbots and AI agent workflows. It enables seamless integration with multiple AI models, including OpenAI, LLaMA, deepseek, Stable Diffusion, and Mistral, through a unified access layer. Intelli also supports Model Context Protocol (MCP) for standardized interaction with AI models.
Features
- Unified API for multiple AI providers.
- Async flow-based agent orchestration.
- Multi-modal support (text, images, speech).
- Model Context Protocol (MCP) integration for standardized model interactions.
- Coding agent and computer-use / browser agent (
agent_type="coder"/"computer").
pip install intelli[mcp]
# computer-use / browser agent (Playwright)
pip install intelli[computer]
python -m playwright install chromium
Latest changes
- Add the coding agent and the computer-use / browser agent (
agent_type="coder"/"computer"). - Update the default models: GPT-5.5, Claude Sonnet 5 / Opus 5, gpt-image-2, Mistral Large, Gemini 2.5.
- Update the speech recognition (speechmatics, Whisper, and more) doc.
- Support MCP capabilities doc.
- Support llama.cpp & GGUF models for fast inference doc.
- Add web search via Search agent.
For detailed instructions, refer to intelli documentation.
Use with Claude Code and Codex
Give your coding agent the Intelli rules, so it writes, runs and explains flows for you.
- Claude Code: run
/plugin marketplace add intelligentnode/Intelli, then/plugin install intelli-flows@intellinode. - Codex, or any project: run
curl -fsSL https://www.intellinode.ai/agent-kit/install.sh | shin the project folder. It adds anAGENTS.mdsection and theintelli-flowsskill. - Then ask in plain words, for example: "Build an Intelli flow that triages support emails and draw its graph."
- Agents can read the full docs index at intellinode.ai/llms.txt.
Code Examples
Create Chatbot
Switch between multiple chatbot providers without changing your code.
from intelli.function.chatbot import Chatbot, ChatProvider
from intelli.model.input.chatbot_input import ChatModelInput
def call_chatbot(provider, model=None, api_key=None, options=None):
# prepare common input
input = ChatModelInput("You are a helpful assistant.", model)
input.add_user_message("What is the capital of France?")
# creating chatbot instance
chatbot = Chatbot(api_key, provider, options=options)
response = chatbot.chat(input)
return response
# call chatGPT (GPT-5.5 is default when model not specified)
call_chatbot(ChatProvider.OPENAI)
# call claude (Sonnet 5 is default, use "claude-opus-5" for Opus)
call_chatbot(ChatProvider.ANTHROPIC, "claude-sonnet-5")
# call google gemini
call_chatbot(ChatProvider.GEMINI)
# call mistral (Mistral Large is default)
call_chatbot(ChatProvider.MISTRAL, "mistral-large-latest")
# Call NVIDIA Deepseek
call_chatbot(ChatProvider.NVIDIA, "deepseek-ai/deepseek-r1")
# Call vLLM (self-hosted)
call_chatbot(ChatProvider.VLLM, "meta-llama/Llama-3.1-8B-Instruct", options={"baseUrl": "http://localhost:8000"})
Chat With Docs
Chat with your docs using multiple LLMs. To connect your data, visit the IntelliNode App, start a project using the Document option, upload your documents or images, and copy the generated One Key. This key will be used to connect the chatbot to your uploaded data.
# creating chatbot with the intellinode one key
bot = Chatbot(YOUR_OPENAI_API_KEY, "openai", {"one_key": YOUR_ONE_KEY})
input = ChatModelInput("You are a helpful assistant.") # uses GPT-5 by default
input.add_user_message("What is the procedure for requesting a refund according to the user manual?")
response = bot.chat(input)
Generate Images
Use the image controller to generate arts from multiple models with minimum code change:
from intelli.controller.remote_image_model import RemoteImageModel
from intelli.model.input.image_input import ImageModelInput
# model details - change only two words to switch
provider = "openai"
model_name = "gpt-image-2"
# prepare the input details
prompts = "cartoonishly-styled solitary snake logo, looping elegantly to form both the body of the python and an abstract play on data nodes."
image_input = ImageModelInput(prompt=prompt, width=1024, height=1024, model=model_name)
# call the model openai/stability
wrapper = RemoteImageModel(your_api_key, provider)
results = wrapper.generate_images(image_input)
Create AI Flows
You can create a flow of tasks executed by different AI models. Here's an example of creating a blog post flow:
- ChatGPT agent to write a post.
- Google gemini agent to write image description.
- Stable diffusion to generate images.
from intelli.flow.agents.agent import Agent
from intelli.flow.tasks.task import Task
from intelli.flow.sequence_flow import SequenceFlow
from intelli.flow.input.task_input import TextTaskInput
from intelli.flow.processors.basic_processor import TextProcessor
# define agents
blog_agent = Agent(agent_type='text', provider='openai', mission='write blog posts', model_params={'key': YOUR_OPENAI_API_KEY, 'model': 'gpt-5.5'})
copy_agent = Agent(agent_type='text', provider='gemini', mission='generate description', model_params={'key': YOUR_GEMINI_API_KEY, 'model': 'gemini-2.5-flash'})
artist_agent = Agent(agent_type='image', provider='stability', mission='generate image', model_params={'key': YOUR_STABILITY_API_KEY})
# define tasks
task1 = Task(TextTaskInput('blog post about electric cars'), blog_agent, log=True)
task2 = Task(TextTaskInput('Generate short image description for image model'), copy_agent, pre_process=TextProcessor.text_head, log=True)
task3 = Task(TextTaskInput('Generate cartoon style image'), artist_agent, log=True)
# start sequence flow
flow = SequenceFlow([task1, task2, task3], log=True)
final_result = flow.start()
To build async AI flows with multiple paths, refer to the flow tutorial.
Pillars
- 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.
- The function layer provides abstract functionality that extends based on the app's use cases.
- Flows: create a flow of ai agents working toward user tasks.
1 maintainer
Metadata
1 maintainer
Release files for intelli 2.1.1
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | |
|---|---|---|---|
| intelli-2.1.1.tar.gz | 310.0 kB | Details |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Reset |
|---|---|---|---|---|
| intelli-2.1.1-py3-none-any.whl | Python 3 | none | any | Details |
Total release size: 688.7 kB
Release files / intelli-2.1.1.tar.gz
| Download URL | intelli-2.1.1.tar.gz |
|---|---|
| Size | 310.0 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
15ab3e483d3114628ac8c91581efc92a06b82322cab10b1e59e0ac1c231082a3
|
|
BLAKE2b-256 checksum How to use checksums |
394610df77b9e576c0fcfbf579ec9d596fe800208bba7e1ea9699764e4e46c12
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.12.4
|
Release files / intelli-2.1.1-py3-none-any.whl
| Download URL | intelli-2.1.1-py3-none-any.whl |
|---|---|
| Size | 378.6 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
58ac30fbde03de7bd9bdf82fa5387901f8adf0a2c7c52c8ca9682eeeb713c421
|
|
BLAKE2b-256 checksum How to use checksums |
a92502cc691728defb63701747f13ee54fb3f5561294c099b6fd363ba6705b71
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.12.4
|
