
A comprehensive web application for analyzing and exploring AI conversation transcripts from multiple platforms. This tool provides a sophisticated interface for navigating complex conversations, visualizing AI thinking processes, and analyzing token usage patterns.

## Powerful Transcript Analysis for AI Researchers and Developers

The AI Transcript Viewer was developed to address the growing need for sophisticated tools to analyze conversations with large language models. As AI interactions become increasingly complex, researchers, developers, and power users need better ways to explore, search, and analyze these conversations.

This standalone web application works seamlessly with transcript files downloaded from our [Claude-ChatGPT Backup Extension](https://humainlabs.ai/projects/claude-chatgpt-backup-extension), providing a complete ecosystem for capturing and analyzing AI conversations. The viewer offers a rich set of features tailored to different analysis needs, from basic navigation to advanced token counting and thinking process visualization.

By providing a dedicated interface for transcript analysis, this tool enables deeper insights into AI behavior, reasoning patterns, and response characteristics across different models and platforms.

## Key Capabilities

The AI Transcript Viewer offers several powerful features for AI conversation analysis:

**Multi-Platform Support** enables seamless viewing of transcripts from ChatGPT, Claude, and other LLMs with automatic format detection and appropriate rendering.

**Three-Message View** provides crucial conversation context by showing the previous, current, and next messages together in a single view.

**Thinking Process Visualization** reveals AI reasoning patterns when available, offering a window into the internal deliberation processes of models like ChatGPT with thinking functionality.

**Token Count Analysis** generates accurate approximations of token usage by message and conversation, helping researchers understand model resource consumption and optimize prompt efficiency.

**Semantic Search** allows users to find content based on meaning rather than just keywords, making it easier to locate specific concepts in lengthy conversations.

**Message Combination** intelligently merges thinking and response messages for models that separate these components, creating a more coherent view of the AI's complete response process.

**Star and Export** functionality lets users mark important messages and export them as JSON for use in new AI context windows, enabling conversation continuity across sessions.

## Practical Applications

The AI Transcript Viewer enables powerful use cases for different user groups:

For **AI researchers**, the tool facilitates detailed analysis of model behavior, helping identify patterns in reasoning, response characteristics, and failure modes across different prompting strategies.

**Prompt engineers** can use the token counting and message analysis features to optimize prompts for efficiency and effectiveness, gaining insights into which prompting techniques yield the best results.

**Developers** working with AI assistants can use the transcript viewer to debug interactions, analyze conversation flows, and extract valuable segments for reuse in development contexts.

**Content creators** can more easily navigate lengthy brainstorming sessions with AI assistants, finding and extracting the most valuable ideas and suggestions.

## Technical Implementation

The viewer is built as a standalone web application using vanilla JavaScript, HTML5, and CSS3 for maximum portability and ease of use. It can be used directly in the browser without installation, or with an optional Node.js-based server for additional features.

Key technical features include:

- Custom tokenization algorithms that approximate token counts for different AI models
- Platform-specific handlers for parsing varied transcript formats
- Keyboard navigation for efficient transcript exploration
- Local-only processing that keeps sensitive conversation data on your device


### Power User Features
- Click the star icon (⭐) on messages to mark them for export
- Use the "Copy Starred" button to export selected messages as JSON
- Click on token counts to view detailed token usage statistics
- Use the search function to find specific content in lengthy conversations either Keyword or Semantic
- Stores bookmarks and semantic vector indexes in localStorage

The viewer is designed to work seamlessly with our [Claude-ChatGPT Backup Extension](https://humainlabs.ai/projects/claude-chatgpt-backup-extension), creating a complete workflow for capturing, storing, and analyzing AI conversations. 

HumainLabs/AI-Transcript-Viewer

AI Transcript Viewer: Multi-Platform Conversation Analysis Tool


**Install the Extension on Firefox**
<a href="https://addons.mozilla.org/en-US/firefox/addon/humainlabs-claude-chat-backup/">https://addons.mozilla.org/en-US/firefox/addon/humainlabs-claude-chat-backup/</a>

A Firefox browser extension that allows users to download JSON transcripts from Claude and ChatGPT conversations, making it easy to load this data into vector databases like ChromaDB or Milvus for advanced analysis and retrieval.

## Simplifying AI Conversation Backup and Analysis

The Claude-ChatGPT Backup Extension was developed to address a common challenge for researchers and developers working with large language models: how to efficiently capture, store, and analyze AI conversations at scale. 

This lightweight Firefox extension provides a simple one-click solution to download structured JSON transcripts of your conversations with Claude and ChatGPT. What sets it apart is its focus on producing clean, well-structured data that's immediately compatible with vector database systems, eliminating the need for complex parsing or transformation steps in your workflow.

By enabling seamless exports to JSON format, the extension creates a direct bridge between your AI interactions and powerful vector databases like ChromaDB and Milvus. This integration unlocks advanced capabilities such as semantic search across thousands of conversations, similarity analysis between different AI responses, and pattern recognition across large conversation datasets.

## Key Capabilities

This extension offers several essential features for researchers and developers:

**One-Click JSON Export** provides instant downloads of your current conversation in a structured JSON format, preserving all messages, timestamps, and metadata for complete context retention.

**Multi-Platform Support** ensures compatibility with both Claude and ChatGPT interfaces, allowing you to standardize your data collection process across different AI systems.

**Vector Database Compatibility** features specially formatted JSON output designed for immediate ingestion into ChromaDB, Milvus, and other vector databases without additional transformation steps.

**Privacy-First Design** operates entirely within your browser with no external API calls or data storage, ensuring your conversations remain private and secure.

## Real-World Applications

The Claude-ChatGPT Backup Extension enables powerful use cases across research and development:

For AI researchers, the extension facilitates the creation of comprehensive training datasets by capturing diverse interactions across multiple models. By exporting to vector databases, researchers can perform sophisticated comparisons between different AI systems and analyze how responses evolve over time.

Developers building RAG (Retrieval-Augmented Generation) applications can use the extension to build custom knowledge bases from their AI conversations. The exported JSON serves as a valuable source of structured data that can be embedded and retrieved to enhance the context available to AI systems.

The extension also supports educational use cases, allowing instructors to capture and analyze AI interactions for teaching purposes or to build curriculum materials around LLM capabilities and limitations.

## Looking Forward

Future development plans for the extension include adding support for additional AI platforms, implementing batch export capabilities for multiple conversations, and creating direct integrations with popular vector database systems for even more streamlined workflows.

We're also exploring options for conversation filtering and tagging features to help users organize and categorize their exported data more effectively.

## Installation & Usage

### Installation
1. Download the extension from the Firefox Add-ons store (coming soon)
2. Or install directly from GitHub:
   - Clone the repository
   - Navigate to `about:debugging` in Firefox
   - Click "This Firefox"
   - Click "Load Temporary Add-on"
   - Select any file in the extension directory

### Basic Usage
1. Navigate to Claude.ai or ChatGPT
2. Have a conversation with the AI
3. Click the extension icon in your browser toolbar
4. Select "Export Conversation"
5. The JSON file will be automatically downloaded to your default download location

### Using with Vector Databases
The exported JSON can be directly imported into vector databases:

```python
# Example with ChromaDB
import chromadb
import json

# Load the exported conversation
with open("claude_conversation_2025-04-11.json", "r") as f:
    conversation = json.load(f)

# Create a ChromaDB collection
client = chromadb.Client()
collection = client.create_collection("claude_conversations")

# Add the messages to the collection
for message in conversation["messages"]:
    collection.add(
        documents=[message["content"]],
        metadatas=[{"role": message["role"], "timestamp": message["timestamp"]}],
        ids=[message["id"]]
    )
``` 

HumainLabs/claude-chatgpt-backup-extension

Firefox Extension: Claude-ChatGPT JSON Export/Backup


A Model Context Protocol (MCP) server that integrates ChromaDB's vector database capabilities with Claude Desktop and Cursor IDE, enabling AI tools to perform natural language queries over document collections.

## Bridging AI and Knowledge Repositories

ChromaDB-MCP emerged from a simple observation: AI tools need context to be truly effective. While large language models possess impressive reasoning abilities, they often lack the specific knowledge needed for specialized tasks. This project bridges that gap by connecting AI tools to your document collections using semantic search.

The server enables your AI assistants to find information based on meaning rather than keywords. When Claude or Cursor needs to answer a question about your data, ChromaDB-MCP retrieves the most relevant documents and provides them as context. This grounds AI responses in your actual information, dramatically reducing hallucinations and improving answer quality.

What sets this project apart is its focus on privacy and simplicity. Unlike cloud-based solutions, ChromaDB-MCP runs entirely on your local machine, keeping your data under your control. The intuitive similarity metrics (0-100%) make it easy to understand search results, while the persistent SQLite backend ensures your document collections remain available across sessions.

## Key Capabilities

ChromaDB-MCP seamlessly connects vector search technology with AI tools through several core capabilities:

**Semantic Understanding** enables natural language queries across your document collections, finding information based on meaning rather than exact keyword matches. The server handles document embedding, storage, and retrieval, presenting results with intuitive similarity scores.

**Document Management** provides complete control over your knowledge base with full CRUD operations. Add new documents, organize them into collections, attach rich metadata, and filter results based on custom criteria.

**AI Integration** offers out-of-the-box compatibility with Claude Desktop and Cursor IDE through the Model Context Protocol. This standardized interface enables AI tools to query your document collections and use the retrieved information to enhance their responses.

## Real-World Applications

ChromaDB-MCP transforms how AI tools interact with your information across various scenarios:

When researching complex topics, the server helps AI assistants pull relevant insights from research papers, articles, and notes. For content creators, it organizes and retrieves information based on conceptual similarity rather than rigid folder structures.

Developers find particular value in code understanding tasks, where the server helps AI tools explore codebases and provide context-aware assistance. The system also serves as a conversational memory for AI assistants, enabling them to recall and reference previous interactions.

## Looking Forward

The ChromaDB-MCP project continues to evolve with planned enhancements including advanced filtering capabilities, support for multiple embedding models, and performance optimizations for large collections. We're also expanding metadata search functionality and integration with additional AI tools to make vector search technology accessible to more applications.

## Installation & Integration

### Prerequisites
- Python 3.12+
- uv package manager (recommended) or pip

### Setup
```bash
# Clone the repository
git clone https://github.com/HumainLabs/chromadb-mcp.git
cd chromadb-mcp

# Create and activate virtual environment
uv venv
# On Windows: .venv\Scripts\activate
# On Unix: source .venv/bin/activate

# Install dependencies
uv pip install -e .
```

### Claude Desktop Integration
Add the server to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "chroma": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/chromadb-mcp",
        "run",
        "chromadb-mcp"
      ]
    }
  }
}
``` 

HumainLabs/chromadb-mcp

ChromaDB-MCP: Vector Database Server for AI Tools



A powerful command-line tool for managing conversational context windows with Claude AI. Forkify enables intelligent document processing and "forking" of conversation branches, allowing you to explore multiple conversational paths from a shared context trunk.

## Overview

Forkify Command Line redefines AI document analysis by enabling sophisticated context window management with Anthropic's Claude AI. The name "Forkify" comes from its core ability to "fork" conversation contexts—creating branches that explore different paths while maintaining a shared base trunk.

The application manages the entire document lifecycle:
1. **Loading documents** into Claude's cache (`input-docs`)
2. **Processing them** into AI-optimized summaries (`processed-docs`)
3. **Storing conversation outputs** for future reference (`output-docs`)

This command-line tool provides a lightweight yet powerful solution for context-aware document processing and conversation management.

## Key Features

- **Context Window Management**: Precisely control how much conversational history is included in Claude's attention window
- **Document Processing Pipeline**: Three-stage pipeline with raw documents, processed summaries, and conversation outputs
- **Conversation Branching**: Fork conversations to explore different paths while maintaining a shared context trunk
- **System Prompt Customization**: Choose different system prompts for analysis, QA, or content generation tasks
- **Response Length Control**: Adjust response length from extremely short (128 tokens) to very detailed (4096+ tokens)
- **Token Usage Monitoring**: Track token usage and associated costs across all conversations
- **Document Source Tracking**: View which documents are being used in the current conversation
- **Session Persistence**: Automatically save and restore conversation state between sessions

## Conversation Branching

The core innovation of Forkify is its conversation branching capability:

```
                    ┌── Branch A: Explore technical details
                    │
Main Conversation ──┼── Branch B: Focus on business implications
                    │
                    └── Branch C: Investigate edge cases
```

**How it works:**
1. You establish a base context "trunk" with your initial documents and conversation
2. Create branches to explore different tangents or conversation paths
3. Each branch maintains its own context window but shares the base trunk
4. Switch between branches without losing your place in either conversation

This approach allows you to:
- Explore multiple analytical angles from the same document set
- Try different prompting strategies without starting over
- Maintain separate conversations that share foundational context
- Preserve trunk attention mechanisms while exploring new directions

## Working with Documents

Forkify implements a three-stage document processing pipeline:

1. **Input Documents** (`input-docs/`): Raw documents loaded into Claude's context
2. **Processed Documents** (`processed-docs/`): AI-optimized summaries and analysis
3. **Output Documents** (`output-docs/`): Conversation history and generated content

This approach ensures efficient token usage while maintaining comprehensive context.

### Sample Session

```
> /sw research_project
Created new conversation 'research_project'
> I need to analyze @@research_paper.pdf
Processing document 'research_paper.pdf'...
Document analysis complete.
> What are the key findings in this paper?
The key findings from the research paper include:
[Claude generates response analyzing the document]
> /branch technical_details
Created new branch 'technical_details' from 'research_project'
> Let's focus on the implementation details in section 3
[Claude responds with technical analysis]
> /sw research_project
Switched to 'research_project' conversation
> Let's discuss the business implications instead
[Claude responds with business analysis while maintaining original context]
```

## Command Reference

Forkify includes a comprehensive set of commands:

| Command | Description |
| ------- | ----------- |
| `/sw <name>` | Create new conversation or switch to existing |
| `/reload` | Reprocess all documents for current conversation |
| `/docs` | Show document sources for current conversation |
| `/p <type>` | Switch system prompt type (analysis\|qa\|generation) |
| `/m` to `/xxl` | Control response length from medium to extremely long |
| `/usage` | Display total token usage and costs |

## Development

The tool is built with Python 3.8+ and structured around the following directories:

* `input-docs/` - Place your input documents here
* `processed-docs/` - Contains processed document data
* `output-docs/` - Contains output generated from conversations
* `sessions/` - Contains conversation session data

The architecture focuses on efficient context management, intelligent document processing, and seamless conversation branching.



HumainLabs/forkify-cmdline

Forkify Command Line: AI Conversation Context Manager


A sophisticated chat interface that implements a trunk and branch+1 methodology for managing AI conversations. This system enables developers to maintain a primary conversation trunk while exploring multiple conversation branches without compromising the original context.

## Key Features

- **Trunk and Branch+1 Methodology**
  - Maintains primary conversation context
  - Enables multiple parallel conversation branches
  - Preserves trunk integrity

- **Context Management**
  - Document caching
  - Configurable context window trimming
  - Intelligent context reintegration

- **Branch Management**
  - Multiple conversation sessions
  - Branch isolation
  - Insight summarization

## Technical Implementation

The system utilizes:
- Document caching for efficient context management
- Configurable context window trimming
- Intelligent branch reintegration
- Context preservation mechanisms

## Use Cases

- Complex conversation exploration
- Multi-threaded AI interactions
- Context preservation in long conversations
- Parallel conversation development

## Future Development

Planned enhancements:
- Advanced context merging
- Branch comparison tools
- Automated insight extraction
- Enhanced visualization

Forkify: Chat Conversation Brancher with Trunk Reintegration




A powerful system for analyzing AI conversations and research transcripts using ChromaDB. This tool enables interactive exploration of conversation data through both API-based and local LLMs, facilitating deep insights into AI interactions.

## Key Features

- **Data Management**
  - Local ChromaDB integration
  - Transcript organization
  - Efficient data storage

- **Analysis Capabilities**
  - Interactive exploration
  - Pattern recognition
  - Insight extraction

- **LLM Integration**
  - API-based analysis
  - Local LLM support
  - Hybrid processing

## Technical Implementation

The system utilizes:
- ChromaDB for vector storage
- API-based LLMs
- Local LLM processing
- Interactive querying

## Analysis Features

Key capabilities:
- **Data Processing**
  - Transcript ingestion
  - Vector embedding
  - Pattern analysis

- **Exploration Tools**
  - Interactive queries
  - Pattern visualization
  - Insight extraction

- **Integration Options**
  - API connectivity
  - Local processing
  - Hybrid analysis

## Use Cases

- AI conversation analysis
- Research transcript processing
- Pattern identification
- Insight generation

## Future Development

Planned enhancements:
- Advanced visualization
- Pattern detection
- Automated reporting
- Enhanced querying

MetaChroma: AI Conversation Analysis System



A sophisticated framework that leverages LangChain, LangGraph, and LangMem to create custom agentic workflows for code generation and modification. The system employs a multi-stage approach with specialized agents to ensure high-quality, consistent code output.

## Key Features

- **Multi-Stage Framework**
  - Intelligent template usage
  - Instruct model integration
  - Agent-based task execution

- **Specialized Agents**
  - Architect Agent
  - Services Agent
  - Controllers Agent
  - Models Agent

- **Workflow Management**
  - Task decomposition
  - Agent coordination
  - Quality control

## Technical Implementation

The system utilizes:
- LangChain for agent orchestration
- LangGraph for workflow management
- LangMem for context persistence
- Template-based code generation

## Agent Specialization

Each agent has a specific focus:
- **Architect Agent**: System design and structure
- **Services Agent**: Service layer implementation
- **Controllers Agent**: Control flow and logic
- **Models Agent**: Data model definition

## Use Cases

- Complex codebase generation
- System refactoring
- Feature implementation
- Code optimization

## Future Development

Planned enhancements:
- Additional agent types
- Enhanced workflow visualization
- Performance optimization
- Integration capabilities

PyBaker: Agentic Workflow Creator



A medium complexity codebase developed using Claude-Sonnet and Aider command line in Cursor IDE. This project serves as a template for efficient AI-assisted development, implementing various strategies for code generation and process optimization.

## Key Features

- **AI Development Integration**
  - Claude-Sonnet integration
  - Aider command line usage
  - Prompting templates

- **Process Optimization**
  - Context management
  - Token optimization
  - Standards adherence

- **Quality Control**
  - Drift monitoring
  - Analysis methodology
  - Change management

## Technical Implementation

The system utilizes:
- AI prompting of command line tools
- Prompting templates
- Context management
- Token optimization

## Development Strategies

Key approaches:
- **AI Prompting**
  - Command line tool integration
  - Template-based generation
  - Context-aware prompting

- **Process Management**
  - Standards enforcement
  - Drift prevention
  - Change tracking

- **Quality Assurance**
  - Analysis methodology
  - Recursive change prevention
  - Process optimization

## Use Cases

- Template application development
- AI-assisted coding
- Process optimization
- Standards implementation

## Future Development

Planned enhancements:
- Additional templates
- Enhanced AI integration
- Process automation
- Quality metrics

Projects