DEV Community: Alex

IntelliNode Generate HTML Pages Directly from the browser

Alex — Wed, 22 Oct 2025 21:50:57 +0000

I have been experimenting with IntelliNode’s npm to generate complete HTML pages directly in the browser without calling backend. Generating directly from GPT-5, cohere, or offline models.

You can simply enter your API key, describe the layout you want, and preview the generated page instantly.

It is lightweight, fast, and ideal for rapid prototyping or testing UI ideas.

<script src="
https://cdn.jsdelivr.net/npm/intellinode@2.3.0/front/intellinode.min.js
" />

Docs: https://docs.intellinode.ai/docs/npm/frontend

Code Example: https://github.com/intelligentnode/IntelliNode/tree/main/samples/frontend

Generate Complete HTML Pages Directly from the Frontend (No Backend Needed ⚡️)

Alex — Wed, 22 Oct 2025 21:42:30 +0000

I always wanted to generate a complete HTML page, such as a landing page, dashboard, or blog, directly from my browser using AI models like GPT 5 or Cohere or offline model. Without calling a backend that only call the LLM backend!

With a lightweight frontend SDK such as IntelliNode
, you can call models, process the response, and render full web pages entirely on the client side.

No server required. No backend setup. Just your API key, a prompt, and instant results in the browser.

Check the sample here, all you need to download the html page and open it!
https://github.com/intelligentnode/IntelliNode/tree/main/samples/frontend

Async AI Workflows with Graph Theory

Alex — Tue, 13 Feb 2024 13:28:47 +0000

Intelli is a Python module that simplifies the orchestration of AI models by employing asynchronous programming and principles from graph theory. Designed for developers and AI engineers seeking to optimize their workflows and connecting different LLM, image or speech models to create complex tasks.

Quick Start with Intelli
To get started with Intelli, make sure you have Python 3.7 or newer. You can install Intelli using pip:

pip install intelli

Applying Graph Theory in Intelli Workflows

When I am talk about using graph theory with Intelli, it is referring to the way tasks mapped to their dependencies. In this model, each AI task is a node in a graph, and dependencies between tasks are edges.

This setup allows you to design workflows where the execution sequence reflects the interrelationships between tasks, facilitating both sequential and parallel processing. This approach is especially beneficial for managing tasks that need to wait multiple I/O operations, mapping between output of previous step to input of current tasks, ensuring that non-dependent tasks can proceed without delay, increasing overall efficiency. Furthermore, intelli promotes a modular approach to task design, enabling the easy reuse of components.

Creating AI Workflows with Intelli

Let’s say you're developing a content creation platform and need to automate tasks using AI models. With Intelli, you define agents for each task. The agent is based on text, image, vision or speech model.

Here's a simplified view of setting up your components:

Defining Agents

from intelli.flow.agents import Agent

# Define an agent for text generation
text_agent = Agent(
    agent_type="text",
    provider="openai",
    mission="write social media posts",
    model_params={"key": self.openai_api_key, "model": "gpt-3.5-turbo"}
)

# Define an agent for image processing
image_agent = Agent(
    agent_type="image",
    provider="stability",
    mission="generate description only",
    model_params={"key": self.stability_key}
)

Defining Tasks

You can define tasks and assign agents to them:

from intelli.flow.tasks import Task
# there are other input types, like image, vision, speech
from intelli.flow.input import TextTaskInput

task1 = Task(
    TextTaskInput("Create a post about AI technologies"),
    text_agent,
    log=True
)

task2 = Task(
    TextTaskInput("Generate image description for AI technologies post"),
    image_agent,
    log=True
)

Defining Flows

After defining tasks, you can orchestrate them using Intelli’s flow management. The system handles task dependencies to ensure they execute efficiently and in the proper order. The task2 will use the output of task1 when generating the images.

from intelli.flow.flow import Flow
import asyncio

async def main():
    flow = Flow(
        tasks={
            "task1": task1,
            "task2": task2
        },
        map_paths={
            "task1": ["task2"]
        },
        log=True
    )

    output = await flow.start()
    print("Final output:", output)

if __name__ == "__main__":
    asyncio.run(main())

you can build more complex flow by utilizing the flexible map feature, example:

map_paths={"task1": ["task2", "task3"], "task3": ["task4"]},

Check full practical code example in the wiki page.

Conclusion

This quick guide introduces the basic steps to automate AI workflows with intelli. While this still in beta phase, the potential of automation with the graph design is huge.

Rerefences

github repo.
pip project.

How to Generate web apps in minutes with AI

Alex — Fri, 09 Jun 2023 19:50:52 +0000

IntelliNode is open source module to connect to any AI model and switch between them without changing your code. You can choose to generate the images from stable diffusion or DALL·E, or text from Openai and cohere without impacting your business app logic.

Following is an app example that that uses IntelliNode to generate web pages from a user prompt:
Register page generation

Another use case is the ability to convert csv files to elegant diagrams without coding:
Dashboard html

The module provides a Gen function that generates tuned business case content in one line:
Generate blog post
const blogPost = await Gen.get_blog_post(prompt, openaiApiKey);

Or generate html pages
await Gen.save_html_page(text, folder, file_name, openaiKey);

For advanced capabilities, you can use the controllers behind the Gen function:

Image generation function

async function generateImage(imageText, apiKey, modelBackend) {
  const imgModel = new RemoteImageModel(apiKey, modelBackend);
  const imageInput = new ImageModelInput({
    prompt: imageText,
    numberOfImages: 3,
    width: 512,
    height: 512
  });
  return await imgModel.generateImages(imageInput);
}

Generate image with stable diffusion:
const images = await generateImage(imageDescription, MyKeys.stability, SupportedImageModels.STABILITY);

Or switch to DALL·E 2:
const images = await generateImage(imageDescription, MyKeys.openai, SupportedImageModels.openai);

To download the node module:
npm i intellinode

You can interact with the module using the show case application:
https://show.intellinode.ai/

Or connect the capabilities to your apps using the github repo:
https://github.com/Barqawiz/IntelliNode

Which functions or capabilities you would like to add to the node module?

IntelliJava: intuitive framework to integrate with AI models.

Alex — Sun, 22 Jan 2023 02:49:27 +0000

Intelligent Java (Intelli Java)

intelligentnode / IntelliJava

Integrate with the latest language models, image generation, speech, and deep learning frameworks like ChatGPT, DALL·E, and Cohere using few java lines.

Intelligent Java

Intelligent java (IntelliJava) is the ultimate tool to integrate with the latest language models and deep learning frameworks using java. The library provides an intuitive functions for sending input to models like ChatGPT and DALL·E, and receiving generated text, speech or images. With just a few lines of code, you can easily access the power of cutting-edge AI models to enhance your projects.

The supported models:

OpenAI: Access ChatGPT, GPT3 to generate text and DALL·E to generate images. OpenAI is preferred for quality results without tuning.
Cohere.ai: Generate text; Cohere allows you to custom your language model to suit your specific needs.
Google AI: Generate audio from text; Access DeepMind’s speech models.

How to use

Add the maven dependency or import the core jar file (check the Integration section).
Add Gson dependency if using the jar file; otherwise, it's handled by maven or Gradle.
Call…

View on GitHub

Detect faces in photos and draw overlay filters

Alex — Fri, 25 Jan 2019 16:48:51 +0000

Detect faces in photos and draw overlay images on it, the overlay drawn using a neural network that detects face key points.

draw glasses
draw mustache
draw hat
draw ears
draw any overlay
draw text

Go to try it: http://ahmadai.com/snappy2/

Note: the code open sourced with love