Guides
/
Developer Dashboard
Last updated

Developer Dashboard

The Papr Developer Dashboard is your command center for building AI applications with persistent memory. Access your dashboard at dashboard.papr.ai to manage your knowledge graph, configure data structures, and monitor your AI's memory system.

Note: The Developer Dashboard is available for Papr Cloud users. Self-hosted deployments can access core features via API. See Self-Hosted Guide.

Dashboard Overview

The dashboard provides a visual interface for:

  • Data Management - Browse, search, and organize your memories
  • Schema Configuration - Define custom entity types and relationships
  • Knowledge Graph Visualization - See how your data connects
  • Interactive Testing - Experiment with features in the Playground
  • Analytics & Monitoring - Track usage and performance
  • API Key Management - Secure access control

Dashboard Sections

Get Started

Your onboarding hub that guides you through initial setup.

What You'll Find:

  • Quick start tutorials
  • Sample projects and templates
  • Integration checklist
  • Video walkthroughs
  • Links to key documentation

Best For: New users getting their first memory integration running

Namespaces

Organize your data by environment, project, or customer. Namespaces provide complete data isolation.

Use Cases:

  • Environment Separation: Development, staging, and production
  • Multi-Tenancy: Different customers or clients
  • Department Isolation: Various teams with separate data
  • Testing Environments: Isolated spaces for experimentation

How to Use:

  1. Click "Create Namespace"
  2. Name it descriptively (e.g., "production", "acme-corp")
  3. Set access permissions
  4. Use the namespace ID in your API calls

API Integration:

# Specify namespace in API calls
client.memory.add(
    content="Memory for specific namespace",
    metadata={"namespace_id": "your-namespace-id"}
)

API Keys

Generate and manage authentication credentials for your applications.

Key Management:

  • Create Multiple Keys: Separate keys for different apps or environments
  • Set Expiration Dates: Enhanced security with automatic expiration
  • Instant Revocation: Revoke keys immediately if compromised
  • Usage Tracking: Monitor which keys are being used

Security Best Practices:

  • Use different keys for development and production
  • Rotate keys regularly
  • Never commit keys to version control
  • Store keys securely (environment variables, secrets managers)
  • Set expiration dates for temporary integrations

Creating a Key:

  1. Navigate to API Keys section
  2. Click "Create New API Key"
  3. Give it a descriptive name
  4. Set optional expiration date
  5. Copy the key immediately (you won't see it again!)

Schemas

Define the structure of your knowledge graph by specifying what types of entities exist and how they relate.

Why Schemas Matter

Consistency

Schemas ensure your data follows a predictable structure:

  • All Person entities have the same properties
  • Relationships are always defined the same way
  • Your AI knows what to expect when querying data

Validation

When adding data, schemas help prevent errors:

  • Only allowed entity types can be created
  • Relationships must connect valid node types
  • Required properties are enforced

Documentation

Schemas serve as living documentation:

  • New team members understand the data model
  • Integrations know what fields exist
  • The graph visualization shows your design

Schema Components

Node Types

Define the categories of entities in your system:

Common Examples:

  • Person: name, email, role, department
  • Project: name, description, status, deadline
  • Task: title, assignee, due date, priority
  • Meeting: date, attendees, location, agenda
  • Document: title, type, author, file path

Creating a Node Type:

  1. Click "Add Node Type"
  2. Name it (singular, capitalized)
  3. Choose a display color
  4. Add properties with types (string, number, date, etc.)
  5. Mark required properties
  6. Set unique identifiers

Relationship Types

Define how entities can connect:

Examples:

  • Person WORKS_ON Project
  • Person ATTENDED Meeting
  • Person CREATED Document
  • Task BELONGS_TO Project
  • Meeting DISCUSSED Project

Creating a Relationship:

  1. Click "Add Relationship Type"
  2. Name it (verb, UPPERCASE)
  3. Select source node type
  4. Select target node type
  5. Add optional properties (e.g., "since_date", "role")

Managing Schemas

Using the Default Schema

Papr provides a pre-built schema that works for most business contexts:

  • Common entity types (Person, Project, Meeting, etc.)
  • Standard relationships
  • Useful properties on each type
  • Ready to use immediately

You can use it as-is or duplicate and customize it.

Creating Custom Schemas

Steps:

  1. Navigate to Schemas section
  2. Click "Create New Schema"
  3. Name your schema descriptively
  4. Choose scope (Organization-wide or Namespace-specific)
  5. Add node types one at a time
  6. Define relationships between your node types
  7. Preview the schema visualization
  8. Set it as active for testing

Schema Visualization

Each schema has a visual preview showing:

  • All node types as colored boxes
  • Arrows showing allowed relationships
  • Relationship names as labels
  • A clean view of your data model

Best Practices

Start Simple:

  • Focus on 3-5 core entity types first
  • Add more types as needs become clear
  • Don't over-engineer early on

Use Clear Names:

  • "Person" not "User" or "Employee"
  • "WORKS_ON" not "Associated_With"
  • Consistency matters more than perfection

Plan Relationships:

  • What information flows between entities?
  • What queries will you need to run?
  • How will the graph be navigated?

Test Before Deploying:

  • Use the Playground to add sample data
  • Verify entity extraction works
  • Check that relationships form correctly
  • Adjust the schema based on results

Views

Browse and explore all your stored data in organized tables.

What You'll See

The Views section provides:

  • Data Tables: All your information in spreadsheet-like format
  • Filterable Columns: Sort and search through data
  • Full Details: Click any item to see complete information
  • Relationship Navigation: Jump between related entities

Available Views

Memory View

See all memories in one place:

Columns:

  • Memory Content (preview)
  • Type (TextMemoryItem, DocumentMemoryItem)
  • Namespace
  • Added By (user)
  • Source (API, Playground, Upload)
  • Topics and categories
  • Created date

Actions:

  • Click a row to see full details
  • Sort by any column
  • Search content
  • Filter by namespace or user

Entity Type Views

One view for each node type in your schema:

Available Views (with default schema):

  • People
  • Projects
  • Tasks
  • Meetings
  • Documents
  • Organizations
  • Locations

Each View Shows:

  • Core properties (name, ID, key fields)
  • Metadata (created date, updated date, namespace)
  • Relationship counts
  • Last activity

Using Views

Memory Detail Page

Click any memory to see:

Content Section:

  • Full text with "Read More" for long content
  • Formatted display with syntax highlighting (if code)
  • Original source information

Metadata Panel:

  • All associated data fields
  • User information
  • Timestamps
  • Tags and topics
  • Source details

Graph Visualization:

  • Connected entities up to 2 hops away
  • Interactive node exploration
  • Relationship types shown
  • Click nodes to navigate

Navigation:

  • Breadcrumbs back to views
  • Links to related entities
  • Quick actions (edit, delete)

Entity Detail Page

Click any entity to see:

Properties Tab:

  • All properties and their values
  • Formatted by type (dates, numbers, text)
  • Links for URL fields

Relationships Tab:

  • Incoming relationships
  • Outgoing relationships
  • Grouped by type
  • Click to navigate to connected entities

Memories Tab:

  • All memories that mention this entity
  • Context snippets
  • Links to full memories

Graph Tab:

  • Visual representation of connections
  • Adjustable depth (1-3 hops)
  • Filter by relationship type

Best Practices

Regular Review

Check your Views regularly to:

  • Verify data is being added correctly
  • Spot duplicate or incorrect entries
  • Monitor data growth over time
  • Ensure metadata is complete

Data Hygiene

Use Views to:

  • Find and fix incomplete records
  • Identify orphaned entities (no connections)
  • Remove outdated information
  • Standardize inconsistent entries

Training & Demos

Views are perfect for:

  • Onboarding new team members
  • Showing stakeholders what data exists
  • Understanding system usage patterns
  • Demonstrating capabilities to clients

Graph

Visualize how your entities connect in an interactive knowledge graph.

What You'll See

The graph displays your data as an interactive network:

Visual Elements:

  • Nodes (boxes): Each represents an entity (person, project, task, etc.)
  • Edges (arrows): Show relationships between entities
  • Colors: Different entity types get different colors for easy identification
  • Labels: Node names and relationship types are clearly shown

Interactive Features

Filtering the View

Use the Filters button at the top to narrow down what you see:

Available Filters:

  • Namespace ID: Show only data from specific environments
  • User ID: Focus on a particular user's entities
  • Entity Type: Show only specific types (People, Projects, etc.)
  • Date Range: Filter by creation or update date

Using Filters:

  1. Click the Filters button
  2. Select your criteria
  3. Apply to update the graph
  4. A red dot appears on the filter button when active
  5. Clear filters to see everything again

Control your view with the toolbar buttons:

Zoom Controls:

  • Zoom In: Get closer to nodes (+ button or scroll up)
  • Zoom Out: See the big picture (- button or scroll down)
  • Fit to Screen: Auto-position all nodes in view
  • Reset View: Return to default position

Display Controls:

  • Refresh: Reload the latest data from your knowledge base
  • Layout: Switch between different layout algorithms
  • Toggle Labels: Show/hide node and edge labels
  • Toggle Legend: Show/hide entity type legend

Inspecting Nodes and Relationships

Click on any node or relationship to see detailed information in the side panel:

For Nodes:

  • Entity type (with color indicator)
  • Label/name
  • All properties and their values
  • Connected memories count
  • Quick actions (view details, navigate)

For Relationships:

  • Relationship type
  • Source and target nodes
  • Any properties on the relationship itself
  • When it was created
  • Quick navigation to source/target

Graph Stats

At the top of the graph, you'll see:

  • Total Nodes: Number currently displayed
  • Total Relationships: Number of connections
  • Legend: All entity types with their colors
  • Filtered: Indicator if filters are active

Understanding the Graph

Node Positioning

The graph uses physics-based layout that:

  • Keeps connected nodes close together
  • Pushes unconnected nodes away from each other
  • Groups related entities naturally
  • Prevents overlapping as much as possible

Manual Positioning:

  • Drag nodes to reposition them
  • Double-click to lock/unlock position
  • Right-click for context menu

Understanding Relationships

Arrows show direction and meaning:

  • The arrow points from source to target
  • Labels on arrows explain the relationship type
  • Example: "Person → WORKS_ON → Project"
  • Bidirectional relationships show two arrows

Node Clustering

The graph automatically clusters:

  • Densely connected nodes
  • Entities of the same type
  • Isolated subgraphs

Colors help identify clusters visually.

Use Cases

Discovering Connections

Find relationships you didn't know existed:

  • See which team members work on multiple projects
  • Understand how tasks relate to goals
  • Track meeting attendees and their involvement
  • Identify key connectors in your organization

Debugging Data

Verify your data structure:

  • Check if entities are being extracted correctly
  • Ensure relationships make sense
  • Identify orphaned nodes (entities with no connections)
  • Find duplicate entities that should be merged

Presentations

Use the graph view to:

  • Demonstrate data relationships to stakeholders
  • Explain system architecture
  • Show knowledge coverage
  • Visualize organizational structure

Analysis

Gain insights from the graph:

  • Identify central nodes (high connection count)
  • Find isolated islands of data
  • Track information flow
  • Understand dependency chains

Playground

Test and experiment with Papr's features in a user-friendly interface without writing code.

Conversational Interface

Chatting with Your Knowledge

The main interface lets you have natural conversations:

How It Works:

  1. Type a question in the chat input
  2. AI searches your knowledge base
  3. Get answers with citations to source memories
  4. Ask follow-up questions with maintained context

Features:

  • Natural language understanding
  • Context retention across conversation
  • Citation tracking
  • Source memory linking

Viewing Citations

When the AI answers your question:

  • Source memories are shown below the response
  • Click any citation to see the full memory
  • Understand exactly where information came from
  • Verify the AI's reasoning and accuracy

Citation Details:

  • Memory snippet that was relevant
  • Relevance score
  • Link to full memory
  • Timestamp and source

Adding Data

Manual Memory Entry

Use the memory input form to add information:

Steps:

  1. Type or paste your content in the text area
  2. Fill in metadata fields (optional):
    • External User ID: Your application's user identifier
    • Source Type: Where this came from (meeting, email, chat, etc.)
    • Source URL: Link to original content
    • Topics: Tags for organization
  3. Choose graph generation mode:
    • Auto: Let Papr extract entities automatically
    • Manual: Specify entities yourself
  4. Click submit to see processing happen in real-time

What Happens Next:

  • Memory is stored
  • Entities are extracted (if auto mode)
  • Relationships are created
  • Vector embeddings are generated
  • Memory becomes searchable immediately

Document Upload

Upload files to have them automatically processed:

Supported Formats:

  • PDF documents
  • Word documents (.docx)
  • Plain text files (.txt)
  • Markdown files (.md)

Upload Process:

  1. Click the document upload button
  2. Select your file (or drag and drop)
  3. Configure chunking options:
    • Flat: Simple equal-sized chunks
    • Hierarchical: Respects document structure (headers, sections)
  4. Add metadata that applies to the whole document:
    • Document title
    • Author
    • Source URL
    • Topics/tags
  5. Click upload and watch it get indexed

Processing Steps You'll See:

  • File upload progress
  • Content extraction
  • Chunking into memories
  • Entity extraction from content
  • Graph generation
  • Completion notification

CSV Import

Bulk import data from spreadsheets:

Importing Nodes

Create multiple entities at once:

Steps:

  1. Click "Import Nodes from CSV"
  2. Select your CSV file
  3. Choose the entity type (Person, Project, etc.)
  4. Map CSV columns to entity properties:
    • Match column names to property names
    • Preview how data will be imported
  5. Validate data types and required fields
  6. Confirm to create all nodes

CSV Format Example:

name,email,role,department
John Doe,john@example.com,Engineer,Engineering
Jane Smith,jane@example.com,Designer,Product

Importing Relationships

Create connections between existing entities:

Steps:

  1. Click "Import Relationships from CSV"
  2. Select your CSV file
  3. Specify the source and target columns
  4. Name the relationship type (WORKS_ON, REPORTS_TO, etc.)
  5. Map any additional properties (since_date, role, etc.)
  6. Preview connections
  7. Confirm to create all relationships

CSV Format Example:

person_name,project_name,role,since_date
John Doe,Website Redesign,Lead Engineer,2024-01-01
Jane Smith,Website Redesign,Designer,2024-01-15

Configuration

Model Settings

Choose which AI model powers the conversation:

Available Models:

  • OpenAI (GPT-4, GPT-3.5-turbo)
  • Claude (Claude 3 Opus, Sonnet, Haiku)
  • Gemini (Gemini Pro, Gemini Ultra)

Adjustable Parameters:

  • Temperature: Controls creativity vs. consistency (0-1)
    • Low (0.1-0.3): Focused, deterministic responses
    • Medium (0.4-0.7): Balanced
    • High (0.8-1.0): Creative, varied responses
  • Max Tokens: How long responses can be
  • Top P: Controls response diversity (0-1)
  • Frequency Penalty: Reduces repetition

Memory Search Settings

Control how the AI finds relevant memories:

Search Parameters:

  • Search Depth: How many memories to consider (5-50)
  • Relevance Threshold: Minimum match score (0-1)
  • Enable Agentic Graph: Use graph traversal for context
  • Max Nodes: Graph entities to include (5-30)
  • Namespace Filter: Limit to specific environments

Optimization Tips:

  • Increase depth for comprehensive answers
  • Lower threshold for broader search
  • Enable agentic graph for relational queries
  • Adjust per use case

Display Options

Customize what you see:

Interface Options:

  • Show/Hide Citations: Toggle source display
  • Auto-Scroll: Automatically scroll to new messages
  • Metadata Display: Show/hide technical details
  • Theme: Dark/light mode toggle
  • Font Size: Adjust for readability

Testing Features

Experiment Safely

The Playground is perfect for:

  • Schema Testing: Test schema changes before production
  • Entity Extraction: See how entities get extracted from text
  • Relationship Formation: Understand how connections are made
  • Search Quality: Validate search results
  • Team Training: Onboard new team members
  • Demos: Demonstrate capabilities to stakeholders

Validation Workflows

Use the Playground to verify:

Data Structure:

  1. Add sample memories
  2. Check entity extraction results
  3. View resulting graph structure
  4. Adjust schema if needed
  5. Repeat until satisfied

Search Quality:

  1. Add diverse memories
  2. Test various queries
  3. Check relevance of results
  4. Adjust search parameters
  5. Fine-tune for your use case

Integration Testing:

  1. Test with production-like data
  2. Verify metadata handling
  3. Check namespace isolation
  4. Validate user permissions
  5. Test edge cases

Usage

Monitor your API consumption and understand your usage patterns.

What You'll Track

API Metrics

Request Counts:

  • Total API calls per day/week/month
  • Broken down by endpoint
  • Success vs. error rates
  • Peak usage times

Memory Operations:

  • Memories created
  • Searches performed
  • Documents processed
  • Entities extracted

Data Storage:

  • Total memories stored
  • Storage size (MB/GB)
  • Growth rate over time
  • By namespace breakdown

Analytics Dashboard

Visual Charts:

  • Usage trends over time (line graphs)
  • Request distribution (pie charts)
  • Endpoint popularity (bar charts)
  • Error rate tracking

Key Metrics Cards:

  • Requests today/this month
  • Memories in system
  • Storage used
  • API keys active

Usage by Namespace

Per-Namespace Breakdown:

  • Requests per namespace
  • Storage per namespace
  • Most active namespaces
  • Isolated billing (if enabled)

Insights:

  • Identify high-usage areas
  • Find optimization opportunities
  • Understand user behavior
  • Plan capacity needs

Setting Up Alerts

Usage Limit Alerts

Configure notifications when approaching limits:

Alert Types:

  • Quota Warning: 80% of monthly quota used
  • Rate Limit: Approaching rate limit
  • Storage Alert: 80% of storage used
  • Error Spike: Unusual error rates detected

Notification Methods:

  • Email notifications
  • Dashboard banners
  • Webhook integration
  • Slack notifications (Enterprise)

Custom Alerts

Create custom rules:

  1. Navigate to Alerts section
  2. Click "Create Alert"
  3. Choose metric to monitor
  4. Set threshold
  5. Choose notification method
  6. Save and activate

Exporting Reports

Usage Reports

Export detailed usage data:

Available Reports:

  • Daily usage summary
  • Monthly billing report
  • API endpoint breakdown
  • Namespace usage details
  • Error logs and patterns

Export Formats:

  • CSV for spreadsheet analysis
  • JSON for programmatic processing
  • PDF for sharing with stakeholders

Scheduling:

  • One-time export
  • Weekly automated reports
  • Monthly billing reports
  • Custom schedules (Enterprise)

Cost Analysis

Cloud Users:

  • Current month spending
  • Projected monthly cost
  • Cost per namespace
  • Trend analysis

Optimization Recommendations:

  • Identify expensive operations
  • Suggest caching opportunities
  • Highlight inefficient patterns
  • Compare to usage tier

Dashboard Tips & Tricks

Keyboard Shortcuts

Speed up your workflow:

Navigation:

  • Ctrl/Cmd + K: Open command palette
  • G then M: Go to Memories
  • G then G: Go to Graph
  • G then P: Go to Playground

Actions:

  • Ctrl/Cmd + N: New memory
  • Ctrl/Cmd + /: Search
  • Esc: Close modal/panel

Search Everything

Use the global search:

  • Press Ctrl/Cmd + K
  • Search across memories, entities, docs
  • Jump directly to results
  • Recent history tracked

Bookmarks

Save frequently accessed views:

  • Bookmark specific filters
  • Save graph views
  • Quick access from sidebar
  • Share bookmarks with team

Dark Mode

Toggle between themes:

  • Settings → Appearance
  • Auto-detect system preference
  • Per-section preferences
  • Scheduled switching

Getting Help

In-Dashboard Support

Help Resources:

  • Click the ? icon for contextual help
  • Tooltips on hover for all features
  • Interactive tutorials
  • Video guides

Quick access to:

  • API Reference
  • Integration guides
  • Code examples
  • Best practices

Support Channels

For Cloud Users:

  • In-dashboard chat support
  • Email: support@papr.ai
  • Priority support queue
  • Enterprise: Dedicated Slack channel

Next Steps

🚀 Quick Start Guide

Get started with the API

🧠 Custom Schemas

Design your data model

📊 Graph Generation

Build knowledge graphs

☁️ Cloud Features

Explore cloud-specific features

Previous page
Next page