DARE Frontend

React/TypeScript frontend for the Dietrich Analysis Research Education (DARE) Platform.

Table of Contents

• What is DARE?
• Screenshots
• Overview
• Quick Start
• Documentation
• Tech Stack
• What is included in this repo?
• What is not included in this repo?
• Stay in touch
• Acknowledgements
• Contributors
• License

What is DARE?

The Dietrich Analysis Research Education (DARE) Platform is an open-source, multi-LLM research and conversation platform. It provides a single, vendor-agnostic interface to OpenAI, Anthropic Claude, Google Gemini, and self-hosted LLaMA models, with file-grounded retrieval (RAG), Model Context Protocol (MCP) tool integration, visual multi-step workflows, and real-time streaming. DARE is built for researchers and institutions that need more than a chatbot — document intelligence, reproducible workflows, and per-user usage tracking in one place.

This repository is the DARE web frontend — the primary user interface for the platform. It connects to the DARE backend over REST and Socket.IO and gives users:

• Multi-LLM chat — streaming conversations with OpenAI, Anthropic, Google, and self-hosted LLaMA models
• File-grounded RAG — upload documents and reference them in chat
• Visual workflow builder — design and run multi-step AI workflows as a DAG
• Prompt templates — reusable, parameterized prompts
• Artifacts — rich rendering for code, diagrams, and documents emitted by the model
• MCP integration — connect to Model Context Protocol servers for tool use

DARE runs standalone. The DARE frontend and backend are all you need to run the platform — nothing else is required. SocraticBooks is a separate, optional platform built on top of DARE.

Screenshots

Usage dashboard — activity, conversations, tokens, and wallet balance, all at a glance the moment you land:

Multi-LLM chat — streaming conversations with per-conversation tools and controls	Workflow builder — multi-step pipelines with conditional routing and human validation
Research mode — agent-gathered sources, human-reviewed before becoming knowledge	Cost tracking — a wallet per user, a ledger per message
Files & RAG — upload and tag a corpus, ground answers in it	Environmental impact — every message metered for energy, carbon, and water, with per-model breakdowns and real-world equivalents

Overview

flowchart TB
    browser["Browser"]

    subgraph frontend["DARE Frontend (React 18)"]
        routes["React Router v6\nRoutes -> Pages"]
        components["Feature Components\nConversation, Workflows, Files, Artifacts"]
        primitives["UI Primitives\nRadix + Tailwind"]
        store["Redux Toolkit Store\nSlices + async thunks"]
        sockets["Socket.IO Middleware\n/chat + /workflow"]
        api["API Layer\nAxios clients by domain"]
    end

    backend["DARE Backend"]

    browser --> frontend
    routes --> components
    components --> primitives
    components --> store
    store --> api
    store --> sockets
    api <-->|REST| backend
    sockets <-->|Socket.IO| backend

Loading

The frontend is a static single-page app: a Redux Toolkit store drives feature components, an Axios API layer talks REST to the backend, and Socket.IO middleware streams chat and workflow events. See docs/architecture.md for the full diagram and component breakdown.

Quick Start

The frontend is a static SPA. For local development, use the Vite dev server. For production, build once and serve the generated dist/ bundle from any static host.

Prerequisites: Node.js 18+ and a running DARE backend (default http://localhost:8000).

# 1. Clone (or pull) the repo
git clone <repo-url> dare-frontend && cd dare-frontend

# 2. Install dependencies
npm install

# 3. Configure environment
cp .env.example .env
# Edit .env — point VITE_DJANGO_BACKEND_URL and VITE_WEBSOCKET_URL at your backend.
# Defaults assume backend on http://localhost:8000.

# 4. Run the dev server (Vite, port 5173)
npm run dev

Then open http://localhost:5173. The dev server hot-reloads on changes.

For a production build:

npm run build       # produces ./dist
npm run preview     # serves ./dist locally for verification

A minimal Docker recipe is in INSTALL.md.

Prerequisites

• Node.js 18+
• A running DARE backend (default http://localhost:8000)

Available Scripts

Command	Description
npm run dev	Start the Vite dev server on port 5173
npm run build	Produce a production bundle in dist/
npm run preview	Serve the production bundle locally
npm run lint	Run ESLint over src/
npm run format	Run Prettier

Documentation

Doc	What's in it
INSTALL.md	Full deployment guide — Docker and bare-metal static hosting
docs/configuration.md	Every Vite environment variable, with type, default, and description
docs/architecture.md	Component diagram, state management, Socket.IO integration
CONTRIBUTING.md	Issues, pull requests, coding standards
docs/RULES.md	Project-specific conventions and constraints
CHANGELOG.md	Release notes
SECURITY.md	Vulnerability disclosure process

Tech Stack

• React 18 + TypeScript
• Vite for build and dev server
• Redux Toolkit for state management
• React Router v6
• Tailwind CSS + Shadcn/ui (Radix UI primitives)
• Socket.IO Client for real-time chat and workflow streaming
• Formik + Yup for forms
• Zod for runtime validation of Socket.IO events
• Axios for HTTP

What is included in this repo?

• src/ — all application source code:
  • api/ — API layer (one file per domain)
  • components/ — UI components by feature (Conversation/, WorkflowBuilder/, FileManager/, Artifacts/, Layout/, and ui/ primitives)
  • redux/ — store, slices, async thunks, Socket.IO middleware, types, and workflow-canvas state
  • pages/, routes/, schemas/ (Zod), config/, and utils/
• docs/ — architecture, configuration, and project rules
• Supporting docs — INSTALL.md, CONTRIBUTING.md, CHANGELOG.md, SECURITY.md

What is not included in this repo?

• dare-backend — the Django REST + Socket.IO backend this frontend depends on (run it separately)
• socraticbooks-frontend — the SocraticBooks frontend (Private Repo for now)
• socraticbooks-backend — the SocraticBooks backend that proxies to DARE (Private Repo for now)

Stay in touch

• Found a bug or have a feature request? Open an issue on the project's GitHub repository.
• Questions or general inquiries? Email the project team at vks@andrew.cmu.edu.
• Security disclosures: see SECURITY.md.

Acknowledgements

DARE is an Open Forum for AI (OFAI) initiative, Carnegie Mellon University Libraries.

The DARE name and marks are owned by Carnegie Mellon University. Use of the name, wordmark, Scotty dog mark, header lockup, and footer badge is governed by the DARE Brand Guidelines & Usage Policy, independently of the software license.

This software integrates with third-party APIs (Anthropic, OpenAI, Google, and others); use of those APIs is subject to each provider's own Terms of Service.

Contributors

DARE is built and maintained by contributors at Carnegie Mellon University and in the open-source community.

Creators

Sayeed Choudhury Creator

Vincent Sha Creator

George Cann Creator

Team

Carl Skipper Contributor	Muhammad Abdurrehman Team Lead	Brian Wingenroth Developer
Farhat Abbas Developer	Hariss M. Developer	Eira Khan QA

License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-only). The software license does not grant rights to the DARE name or marks; see the DARE Brand Guidelines & Usage Policy.

See the LICENSE file for the full license text, or visit https://www.gnu.org/licenses/agpl-3.0.en.html.