satellitecomponent/neurite

Fractal Graph Desktop for Ai-Agents, Web-Browsing, Note-Taking, and Code.

Neurite

Introduction

💡 neurite.network unleashes a new dimension of digital interface...

...the fractal dimension.

Bridging Fractals and Thought

🧩 Drawing from chaos theory and graph theory, Neurite unveils the hidden patterns and intricate connections that shape creative thinking.

For over a year, we've been iterating out a virtually limitless workspace that blends the mesmerizing complexity of fractals with contemporary mind mapping technique.

Why Fractals? The Mandelbrot Set is not just an aesthetic choice - fractal logic is ingrained into a countless number of natural and constructed phenomena - from polynomial equations, to art and music - even the cosmic web. 🌀 Fractals act as the cross-disciplinary framework for non-integer dimensional thought - where conventional notions of 4D spacetime are put into question. The goal of this project is to grow agentic graphs of fractal creativity & collaboration.

First of its Kind Fractal Zoom

neurite.network is unique in its ability to seamlessly navigate the Mandelbrot set in real time! 🚀

Movements through the fractal are no longer interrupted at each step. Instead, the rendering persists and regenerates as you interact...

Why Nodes?

Nodes represent text, images, videos, code, and AI agents. Together, they thread a personalized microcosm of your thoughts and inspirations. 🔭

neurite.network connects physics simulation of graphs with an underlying fractal topology to kinematically define interactive, iterative, and modular graphs of ideation.

Complexity Inspires Creativity / Basins Attract

Whether you're a researcher, writer, artist, developer, educator, or simply a curious thinker, Neurite offers a departure from the conventional interface. It's an interactive landscape tracing your ever-branching pathways of thought.

🌐 Available through Github Pages: neurite.network 🌐

⚠️ Warning: Contains zooming, flashing lights, and colors which may not currently be suitable for people with photosensitive epilepsy.

🌱 This is an open-source project in active development, feel feel to join our team on Discord

Table of Contents

1. Introduction
2. How to Use Neurite
3. Synchronized Knowledge Management
4. FractalGPT
5. Local Ai
6. User Guide
7. Local Server Setup
8. Neural API
9. Future of Neurite
10. Contact

How to Use Neurite

📚 Neurite lets you embed anything - text, photos, audio, video, PDFs, AI, and webpages - directly within the Mandelbrot set.

Drag and drop or Paste local files and web content straight into the fractal.

⚙️Controls⚙️

Category	Key/Combination	Action
Navigation	Click and drag	Move around
	Scroll	Zoom through the fractal
Node Essentials	Shift + double click	Create text node
	Shift	Freeze time
	Hold Shift + click	Connect two nodes
	Double click	Anchor a node
Node Selection & Arrangement	Alt/Option + Drag Node	Arrange the node (avoids text selection)
	Alt/Option + Click	Select nodes
	Alt/Option + Drag Canvas	Select multiple nodes
	Arrow Keys	Move selected nodes
	d	Scale selected nodes down
	f	Scale selected nodes up
Fractal Controls	Edit Tab	Main sliders for fractal rendering and color
	Alt/Option + f	Freeze the currently displayed fractal lines
	Alt/Option + c	Clear any frozen lines
	Alt/Option + s	Save the fractal lines as a PNG

Custom ## title and [[reference]] tags can be set in the Zettelkasten Settings. To access the Zettelkasten Settings, click the note icon in the top left corner of the dropdown.

*Full controls are listed in the ? tab within Neurite's main dropdown.

UI Tips

• Optimal Node Placement: Zoom in Scroll to create space for new nodes to ensure they have room to expand.
• Managing Windows: Drag windows by their title bar and resize by scrolling while holding Shift.
• Freezing Nodes: Hold Shift to freeze nodes in place, then double click the nodes to anchor them in place.
• Ai Tutorial: In the '?' tab, the AI HOW-TO checkbox will send a context message to the AI that allows it to answer questions some questions about Neurite.

Synchronized Knowledge Management

neurite.network Markdown formatted, bi-directional synchronization between UI-focused Mind-Mapping and text-based hyperlinking. FractalGPT: Engage with non-linear, rhizomatic memory through our biomimetic interface. Local AI: Privacy-focused, connect to any locally hosted instance of Ollama. Vector Embeddings: Grow a database of memories that can be switched out as context for an increasing number of Ai systems. Chaos and Order: Navigate through the depths of a non-linear environemnt for grappling with the interplay between logic and irrationality

Dynamic Fractal Backdrop: Interactive, multi-media orchestration. Zoom-to-Node: Navigate directly to and between nodes within the Mandelbrot set. Bi-Directional Sync: Real-time updates between Mind Map and Zettelkasten. Zettelkasten and Mind Mapping: Nodes are dynamic objects that can be interacted with from any approach. Endless Exploration: Build custom interfaces within Neurite for any task you have in mind.

Build your Zettelkasten through UI interactions in the Mind Map, and reciprocally shape the Mind Map through text-based note-taking in the Zettelkasten. This navigational fluidity offers unprecedented control over both the granular and macroscopic perspectives of your information.

FractalGPT

Not your typical chat interface

Modular Conversation In Neurite, you don't just interact with AI; you grow its contextual memory, thanks to: Structured Memory Mapping: Anchor the AI's thought process as notes within an evolving fractal mind map. Graph your AI Conversations: Segment AI's responses into a cohesive web of thought that both improves AI reasoning and allows for the history of your chain of thought to dynamically construct the Ai's memory. Interactive Fractal Network: Neurite's fractal interface acts as a personal, emergent, and contextually aware database of knowledge. Intuitive Note Navigation: Effortlessly access and pull your notes into view, no matter where they are within the fractal landscape. Fractals are the rabbit hole for endless exploration of thought!

Unbounded AI Collaboration

An open world generative landscape for thought integrated with artificial intelligence.

AI Inference Providers

Local	Cloud
Ollama	OpenAI
transformers.js	Groq

Neurite Supports the following AI Plugins: ⚡

Plugin	Description
Auto Mode	Enable the AI to recursively generate its own prompts.
Long-Term Memory	Utilize nodal recall through our vector-embedded search of your notes and conversation. Includes experimental forgetting mode in the ? tab.
Experimental Code Editor	HTML/JS: Render GPT's code output directly. Connected nodes bundle together any HTML/CSS/JS codeblocks or editors. Python (Pyodide): Execute Python code directly within the browser.
Web Search	Utilize the Google programmable search API to retrieve webpages that can be sent as context to the AI.
Understands Webpages and PDFs	Leverage a local vector database to extend the AI's context window.
Wikipedia Results	Retrieve the top 3 Wikipedia results or shuffle through the top 20.
Wolfram Alpha Results	Display Wolfram Pods as nodes.

All API keys can be input through the AI tab in the menu dropdown.

Local Ai

🤖 Multi-Agent Chat Networks 🤖💬🗨️🤖🗨️🤖 Connected Ai nodes send messages to one another. This idea contains endless possibilities. (Hold Shift and Click two node windows to connect them together) Supports Local and Cloud based models concurrently. flow-based Ai-Agents ⛓️💭 🔄 Message Looping: Initiate conversational threads across connected AI nodes. Prompt Generation: Upon connection, AI nodes are programmed to end responses with a question or prompt, which is then sent to any other connected nodes. Unique & Shared Instructions: Unique Instructions: Connect text nodes exclusively to a specific AI node to give it private system instructions, isolated from other connected AI nodes. Shared Instructions: Text nodes can send instructions to multiple AI nodes as long as there are no other AI nodes between them. This ensures that once another AI node is found in the connected graph, all preceding connected nodes are excluded from the current AI's instruction set. Related Research: Conversational Swarm Intelligence Paper

User Guide

To run Neurite locally,

either:

1. Clone the repository
2. Open the index.html file in your browser (note: local AI features will not be enabled)

Or, to enable local AI features without using our Github pages host above:

1. Navigate to the cloned directory in your terminal (either main or local-ai branch)
2. Install any necessary global dependencies when running the below, (Vite)

npm install
npm run build
npm run start

Local Server Setup

The Localhost Servers are an important component of Neurite that serves as an optional backend for complelte functionality.

Download Localhost Servers here.

The servers enable plugin integration for webpage/pdf text extraction, Wolfram Alpha, and Wikipedia.

• The localhost servers require npm and Node.js
• Without any servers running, Wolfram, Wiki, and Webpage extractions will not function.
• All servers can be run with one command. Download the Localhost Servers folder, or find it in your cloned directory. Once navigated to the Localhost Servers folder in your command line, run

  node start_servers.js

This will run all of the servers at once. They'll work on our Github pages host of Neurite, or any other way you locally access the interface.

As of our recent update, the servers now support an Ai proxy that connects Neurite to any inference backend.

Final Notes

• Search: Our distinctive search mechanism transports you through your intricate web of thoughts, directly zooming to the node you are looking for. The navigational experience isn't just a gimmick; it also helps to reinforce the spatial memory of where that piece of information resides within the larger framework.
• Saving: Your networks can be saved within the browser cache, or downloaded as a .txt file. Drag the .txt file into the save box, click load on the imported file, then click the second load button to display the network. 💾 Saving has been significantly enchanced! Now, node interactivity, fractal settings, and the Zettelkasten sync all fully restore when loading networks from the save tab...
• Zettelkasten and Mind Mapping: Create nodes through custom-defined syntax, or create nodes through UI interaction within our fractal workspace, who's contents are bi-directionally linked to the main Zettelkasten document.
• Fractals: We achieve real-time navigation of the Mandelbrot set by capturing a sparse set of points from the fractal and connecting them through SVGs. From there, we dynamically adapt the level of detail based on your viewport and cursor position. This evolving method is what ensures seamless fractal generation, interaction, as well as an expanding array of customizability options.

Neurite realizes tapestry of thought reasoning for Ai, all within our innovative real-time Mandelbrot visualization.

• Talk to the custom GPT, Neurite GPT with access to Neurite's code and readme. (This is not the ai that interacts with Neurite itself)

Long Term Memory for Ai Neurite incorporates note-taking to retain a non-linear conversation history. We feed both the recent conversation as well as any matched notes that are not already in the recent conversation as part of the context message to the Ai. This means retaining relevant information from any part of the conversation regardless of the Ai's context window size. Still, advancements in context window size only further enable Neurite's performance.

Neural API

Expirimental Update: Function Calling Panel This feature is a terminal that allows you to execute Neurite's code from within Neurite itself. Included with the function calling panel update is our Neural API. The Neural API is a growing collection of existing features within Neurite, made for sequencing animations of function calls. The current features include: Animate movements through the Mandelbrot set Determine exact coordinates to zoom to Call GPT 4 Vision to determine the next movement (set number of iterations) Create notes Prompt the Zettelkasten Ai Prompt the user Search and Zoom to Notes You can call on GPT to construct the sequences of function calls itself. It has access to the documentation. For the current documentation, try calling the below from within the function panel: const neuralAPI = neuralApiPrompt(); console.log(neuralAPI); The current Neural API documentation will display in your call history for the function calling panel as well as in your browser console. There will be more information on this soon. This is a new feature in initial release.

Future of Neurite

Neurite is a recursive environment for generating ideas. The project combines fractals, mind-mapping, and ai to enable an experimental, yet powerful playground for research, code generation, writing, learning, and visualizing thought.

🚧 Neurite is in active development. 🚧

✅ Ollama (local Ai)

✅ local embeddings

• VR

🔄 deeper fractal zoom

✅ Global Function Calling

✅ Cellular Automata

✅ Multi-Agent Chat

✅ Advanced Control over Node Placement

✅ color selection

✅ adjust fractal generation (width, length, max lines, speed)

✅ screen recording

✅ Improved Saving

🔄 accessibility

• custom equations for the fractal
• drawing-tool

🔄 Experimental Features

🔄 user feedback/bug fixes

🔄 pull requests

Depreciations: webLLM 🚧

Choose_Your_Own_Adventure.mov

Contact

If you are a developer who is interested in contributing to this project, contact us at [email protected] or visit our discord 🔗

full video [here](https://youtu.be/1VmE_Bov-Xw)

neurite's Issues

New lines lost when saving Ai node Code Blocks.

While all other aspects of Ai nodes are saved, restored codeblocks within Ai nodes currently miss all new lines. This does not actually effect code execution or Ai memory but would be nice to fix. The relevant code is in ainodes.js

Syntax Highlighting within Text Nodes

While I have made a few attempts to get syntax highlighting within text nodes, they have not been sufficient enough solutions for release. Having syntax highlighting for reference tags and even code blocks within nodes would be a significant enhancement to Neurite.

The relevant files are in

Neurite\js\nodes\createnodes\nodedef.js
createnodes\contenteditable.js

Zettelakasten misses connections on paste.

In the case of pasting notes into the zettelkasten, not all connections between nodes are recognized.

We use the processAll flag to enable the ZettelkastenrProcessor to handle all nodes as opposed to just the currently changed individual node. This allows for much more efficient input to individual nodes while still handling cases where all nodes need to be processed.

All connections between notes in the zettelkasten that are not found on paste can be restored by creating a node using SHIFT + DOUBLE CLICK in the fractal. This is another case where processAll is set to true. Handling the paste event is more troublesome. and does not seem to set the processAll flag correctly. One issue could be having to recognize the paste event manually in zetcodemirror.js.

The relevant code is in the zettelkasten folder found in the js folder. At the top of zetcodemirror.js and the entirety of zettelkasten.js.

Issues running local model on Linux

Running it on kali linux and im having an issue utilizing the local model. the check box is tick on but when i click install nothing happens... it would be nice to have an acknowledgment or a progress bar...

Ensure Ai Node Response Halting

Especially now that we rely on multiple local and remote providers, it is important to handle each abort request appropriately and test.

Issues of safety and control with regards to Ai nodes is still in its infancy. It is important to get this right sooner rather than later.

At some point, a global modal element could be added for further control.

connecting AI nodes together results in errors

Connect two or three AI nodes together, give them rules in how and when to reply to one another. Then connect them together and ask one a question. You get about 2 messages in before prompt error floods. Are they meant to be linkable this way or have I missed something?

Rendering Issues on Mobile

When using pinch to zoom on an iphone in safari, there are times when the rendering fully disappears. This occurs in some areas more than others, and the rendering can reappear from changing the position/zoom.

Improve Zettelkasten Parsing

The parsing for nodes and edges has been improved over time, but is still a major undertaking.

There is still room for further testing, validation, and potentially major efficiency improvements.

Auto save the content to local storage at least

Hi,

Thanks for building such a talented application. I love the idea of fractal workspace of text links.

When I was playing with Neurite, I met two times of data loss accidentally. I accidentally close the browser tab by clicking the close tab shortcut I set before first time. Then I try to explorer the local ai feature, and the app suddenly crashed. It make me frustrated and can't trust the app.

Can we auto save the data to local storage and let user load them if necessary?

Thanks.

Event listeners not restored for saved networks.

A not yet implemented improvement is the ability for saved networks to retain their event listeners.

Improve Ai Nodes

A reminder that Ai nodes are still at an early stage in their implementation and could require significant improvement and spawn many additions.

The main thing right now is to further test them, improve their safety/error handling, then we can move on to increasingly interesting additions.

It would take as long to explain all the potential ideas as it would to build them, so I would rather just get to the building part.

Right now, they already have a significant feature set, but are not fully reliable yet.

Refine Node Types

While I am about to implement a whole range of types of nodes within the text nodes themselves via syntax highlighting, refactoring the way in which nodes are defined has a number of downstream benefits.

Create system for duplicate titles when typed from the Zettelkasten

While duplicate titles are avoided when entering titles from node headings, this is not the case when typing into the Zettelkasten.

Fixing this issue would ensure any duplicate Ai titles are handled properly.

The relevant files are in the Zettelkasten folder.

error running servers

Primary app runs fine, nice work -- but there may be an issue with the servers:

node start_servers.js
file:///mnt/repos/Neurite/Localhost%20Servers/start_servers.js:1
const { spawn } = require('child_process');
^

ReferenceError: require is not defined in ES module scope, you can use import instead
This file is being treated as an ES module because it has a '.js' file extension and '/mnt/repos/Neurite/package.json' contains "type": "module". To treat it as a CommonJS script, rename it to use the '.cjs' file extension.
at file:///mnt/repos/Neurite/Localhost%20Servers/start_servers.js:1:19
at ModuleJob.run (node:internal/modules/esm/module_job:194:25)

Node.js v18.15.0

Flickering between Mandelbrot recalculation.

One of @Paul-31415's fascinating contributions to Neurite is the ability for the fractal rendering to fully recalculate the svg positions at moments when a full refresh of the view is necessary. This is a significant reason why one can zoom so far into Neurite and could perhaps always have potential for both creative and/or obvious further iterations.

The relevant code is found in mandelbrot.js

Here is a snippet.

function recalc_svg(oldSVGpan,oldSVGzoom) {
    let node = svg_bg;
    for (let c of node.children){
        let path = c.getAttribute("d");
        let parts = path.split(/[, ]+/g);
        let coord = 0;
        let r = [];
        for (let p of parts){
            if (p.length && !isNaN(Number(p))){
                let c = coord?'y':'x';
                p = Number(p)/oldSVGzoom + oldSVGpan[c];
                p = (p-SVGpan[c])*SVGzoom;
                coord = 1-coord;
            }
            r.push(p);
        }
        c.setAttribute("d",r.join(" "));
        c.setAttribute("stroke-width",c.getAttribute("stroke-width")*SVGzoom/oldSVGzoom);
    }
}

This area of the code is the most directly relevant but is also not the full picture.

The current version of the recalculation is vastly improved from its initial

// TODO

however, one issue is a flickering where it appears the view is rotated for a frame before correctly restoring.

This is an issue which may not even be that hard to fix compared to what we have tackled so far, but is an area of the code I wanted to point out, as it is an entry-point into thinking about how the fractal rendering methods could be further expanded upon.