Graphite 2 is here! (formerly Graphite) - https://github.com/dovvnloading/Graphlink

---

Graphite: A Visual Node-Based LLM Interface

Graphite is an advanced desktop environment for human–AI collaboration. It transforms traditional chat into a visual reasoning workspace where ideas branch, connect, and evolve.

Built with Python and PySide6, Graphite integrates Ollama, OpenAI, Gemini, Anthropic, and Groq models to provide a secure, local-first environment designed for research, creative exploration, and structured reasoning.

---

Big news at bottom of repo

---

Table of Contents

• Overview
• Key Features
• Gallery
• Technical Architecture
• Technology Stack
• Installation and Setup
• Usage
• Contributing
• License

Overview

Traditional chatbot interfaces confine conversations to a single chronological timeline. While convenient, this format makes it difficult to revisit ideas, branch alternative reasoning paths, or organize complex lines of thought.

Graphite addresses this limitation by transforming conversation into a visual graph structure on an infinite canvas. Each prompt and response becomes a distinct node, visually connected to represent the evolving structure of the dialogue.

This approach allows users to trace how ideas develop, branch conversations from any point, explore alternative reasoning paths, and build an interconnected knowledge workspace while keeping all data fully private on the local machine.

Key Features

• Node-Based Visual Interface: Move beyond linear text logs. Every interaction appears as a draggable, selectable node on an infinite canvas.
• Non-Linear Conversation Flow: Branch conversations from any existing node to explore alternate ideas without disrupting the original thread.
• Local and Private LLM Integration: Powered by Ollama, AI processing can occur entirely locally. Conversations never leave your machine, ensuring complete privacy.
• Flexible Model Selection: Choose from preset models or specify any model compatible with Ollama. The application verifies model availability locally before use.
• Rich Organizational Tools:
  • Frames: Group nodes into labeled clusters with customizable titles and colors.
  • Notes: Add persistent sticky notes to annotate ideas or capture reminders.
  • Navigation Pins: Mark important nodes and access them instantly through a navigation overlay.
• AI-Powered Content Generation:
  • Chart Generation: Ask the AI to summarize data and generate matplotlib charts (Bar, Line, Pie, Histogram, and Sankey) directly on the canvas.
  • Key Takeaways & Explainers: Right-click any node to generate summaries or simplified explanations that appear as formatted notes.
• Advanced Canvas Controls:
  • Infinite Canvas: Pan and zoom across a virtually unlimited workspace.
  • Custom UI Controls: Adjust grid snapping, panning speed, zoom levels, and other interaction parameters.
• Comprehensive Session Management:
  • Chat Library: Save, load, rename, and manage multiple conversation canvases.
  • Secure Local Database: All sessions—including nodes, frames, notes, and pins—are stored locally in a SQLite database.

Gallery

---

Technical Architecture

Graphite is built on a modular architecture designed for maintainability and scalability. The application is written in Python 3 and leverages the PySide6 framework to provide a cross-platform graphical interface. The architecture emphasizes a clear separation of concerns between UI components, core application logic, and AI services.

The project is organized into several primary modules:

• graphite_app.py: The main application entry point. It contains the primary ChatWindow class responsible for assembling the UI, initializing backend services, and managing the main event loop.

• graphite_ui.py: The full user interface layer. This module defines all Qt-based components, including dialogs (APISettingsDialog, ChatLibraryDialog) and custom-rendered QGraphicsItem objects that power the interactive canvas, such as ChatNode, ConnectionItem, Frame, Note, and ChartItem.

• graphite_core.py: The application's central state management and persistence layer.

  • ChatSessionManager serializes the canvas scene graph (nodes, connections, frames, etc.) into JSON and reconstructs sessions from stored data.
  • ChatDatabase manages the local SQLite database used to store and retrieve saved chat sessions.

• graphite_agents.py: Contains the logic for AI-driven tasks. Agents include the base ChatAgent along with specialized agents such as KeyTakeawayAgent, ExplainerAgent, and ChartDataAgent. Each agent performs network operations within a dedicated QThread worker to ensure the interface remains responsive.

• api_provider.py: An abstraction layer responsible for routing requests to the appropriate model provider. It supports both local Ollama instances and OpenAI-compatible remote APIs, allowing the application to remain independent of specific providers.

• graphite_config.py: Centralized configuration file containing global constants, task identifiers (TASK_CHAT, TASK_CHART), and default model names.

Technology Stack

• Language: Python 3.8+
• UI Framework: PySide6
• Local LLM Interface: Ollama
• Charting Library: Matplotlib
• Database: SQLite
• Icons: QtAwesome (FontAwesome)

Installation and Setup

Follow these steps to run Graphite locally.

1. Prerequisites

• Python: Python 3.8 or newer
• Ollama: Installed and running — https://ollama.com

2. Install an LLM Model

Pull the default model used by the application:

ollama pull qwen2.5:7b-instruct

Additional models can be configured inside the application using the model selection dialog.

3. Clone and Install Dependencies

Clone the repository:

git clone https://github.com/dovvnloading/Graphite.git
cd Graphite

Create a virtual environment (recommended):

# Windows
python -m venv venv
.\venv\Scripts\activate

# macOS/Linux
python3 -m venv venv
source venv/bin/activate

Install dependencies:

pip install -r requirements.txt

If no requirements.txt is available:

pip install PySide6 ollama matplotlib qtawesome

4. Run the Application

python graphite_app.py

Usage

• Sending Messages: Enter a prompt in the input box and press Enter to create a new node followed by the AI response.

• Branching Conversations: Select any existing node to use it as the context for a new branch.

• Node Interaction

  • Move: Drag nodes to reposition them.
  • Select: Click to select or drag to select multiple nodes.
  • Context Menu: Right-click nodes for actions such as copying text, generating summaries, creating charts, or deleting nodes.

Keyboard Shortcuts

• Ctrl + F — Create a Frame around selected nodes
• Ctrl + N — Create a Note at the cursor position
• Delete — Delete selected items
• Ctrl + S — Save the current chat session
• Ctrl + L — Open the Chat Library

---

Known issue: Graph generation can sometimes be unstable. Larger models generally produce better chart data but require significantly greater system resources. Using coding-oriented models may improve chart accuracy.

---

Contributing

Contributions are welcome.

1. Fork the repository.
2. Create a branch for your feature or bug fix (git checkout -b feature/your-feature-name).
3. Commit your changes with clear and descriptive messages.
4. Push your branch to your forked repository.
5. Open a pull request describing the changes and rationale.

For major changes, please open an issue first to discuss the proposed modification.

License

This project is licensed under the MIT License. See the LICENSE file for details.

---

---

---

Updated - 3 / 28 / 2026

Graphlink — formerly Graphite

Graphite 2 has arrived under a new name: Graphlink.

The name Graphite has become saturated across multiple unrelated projects, creating confusion and potential legal complications. To ensure the project remains clearly identifiable moving forward, Graphite is now considered a legacy name, and development will continue under the new name Graphlink.

Graphlink represents the next stage of the original system, expanding the tooling, architecture, and capabilities introduced in Graphite v1.

Repository: https://github.com/dovvnloading/Graphlink