Mirix — Multi-Agent Personal Assistant with Six-Part Memory (Screen and Conversation)

Personal assistant that builds memory from what it sees and hears: six memory agents (core, episodic, semantic, procedural, resource, knowledge vault) sit under a meta-agent, with reflexion and background consolidation passes. PostgreSQL with BM25 and vector search, FastAPI server, React dashboard, Python client, text/image/voice/screen input, local-first storage. Docker Compose to start; OpenAI, Anthropic or Gemini models.

Uploaded by TalentDelta Team Member (Scout) · via TalentDelta

Agent Memory Knowledge Base Management Knowledge Graph Construction Note-Taking Vector Search Workflow Automation AI Agents Productivity and Collaboration Information Technology

build 1.0.0 · 4046.9 KB · published 2026-10-24 · 496 files

Licence: Apache-2.0

Provenance

Scouted from github.com/Mirix-AI/MIRIX at commit 8cb06a62bbb7c478beb33dd4f2815696a72df482 (2026-08-20). Licence Apache-2.0. Upstream credit: Mirix AI (Mirix-AI). Packaged byte-identical to the pin apart from the provenance record appended to README.md. Upstream code and licence stay upstream's.

Brought into the catalogue by TalentDelta Team Member (Scout).

Our review

What we like

Six memory agents — core, episodic, semantic, procedural, resource, knowledge vault — alongside meta, background and reflexion agents, over 317 Python files: 39 prompts, 44 schemas, 31 ORM models, 33 services, a dashboard, tests and evaluation harnesses. Apache-2.0, licence shipped.

Potential improvements

The compose file and environment template default the database password and JWT secret to fixed values; both say to generate your own, so change them before the dashboard leaves localhost. Two README references are not in the archive.

Minimum requirements

Docker Compose and one model-provider key. The stack brings its own pgvector Postgres and Redis.

Security risks

It captures screen and conversation content, so it accumulates personal data: protect the database volume and the dashboard login. Default credentials ship in the compose file.

Tested: packaging, counts, licence and credential sweep. Not tested: a live install.

496 files · 10583.2 KB · previews are generated at approval and never executed

mirix-personal-memory-agent/.claudeignoretext · 0.1 KB

.venv/
build/
*.egg-info/
mirix.egg-info/
.persist/
__pycache__/
*.pyc
.pytest_cache/
node_modules/
dashboard/node_modules/

mirix-personal-memory-agent/.cursorignoretext · 0.1 KB

.venv/
build/
*.egg-info/
mirix.egg-info/
.persist/
__pycache__/
*.pyc
.pytest_cache/
node_modules/
dashboard/node_modules/

mirix-personal-memory-agent/.cursorrulestext · 8.0 KB

# MIRIX Project Rules for Cursor AI

## Project Overview
MIRIX is a Multi-Agent Personal Assistant with an Advanced Memory System. It features a six-agent memory architecture (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) with screen activity tracking and privacy-first design.

## Tech Stack
- **Backend**: Python 3.10+, FastAPI, PostgreSQL, Redis, Kafka
- **Frontend**: React, TypeScript, Vite, TailwindCSS
- **LLM Integration**: Multiple providers (OpenAI, Anthropic, Google, Azure, etc.)
- **Observability**: LangFuse
- **Testing**: pytest
- **Linting**: Ruff, Pyright

## Code Standards

### Python Guidelines
1. **Follow PEP 8** strictly
   - Use 4 spaces for indentation (no tabs)
   - Max line length: 79 characters for code, 72 for docstrings
   - Use snake_case for variables/functions, CamelCase for classes, ALL_CAPS for constants
   - Group imports: standard library, third-party, local application (blank lines between groups)

2. **Type Hints**
   - Always use type hints for function signatures
   - Use `Optional[T]` for nullable types
   - Use `Union` or `|` syntax for multiple types
   - Example: `def create_user(user_id: str, name: Optional[str] = None) -> User:`

3. **Documentation**
   - Use triple-quoted docstrings for all modules, classes, and functions
   - Include parameter descriptions, return types, and examples where helpful
   - Document complex logic with inline comments explaining WHY, not WHAT

4. **Error Handling**
   - Use specific exception types (ValueError, TypeError, HTTPException, etc.)
   - Never use bare `except:` clauses
   - Log errors with appropriate context

5. **Async/Await**
   - Use async/await for I/O operations
   - Prefix async functions with `async def`
   - Always await async calls

### Async Architecture (Critical)
The codebase is fully async-native. Violating these rules will break the server.

1. **All new manager methods in `mirix/services/` MUST be `async def`**
2. **Never call `asyncio.run()` inside the server** — the event loop is already running
3. **Never use sync DB drivers** — use `asyncpg` (not `pg8000`), `aiosqlite` (not `sqlite3`)
4. **Never use sync Redis** — use `redis.asyncio` only, never `redis.Redis`
5. **Never use `requests`** — use `httpx.AsyncClient` for all HTTP calls
6. **Wrap unavoidable sync calls** with `asyncio.to_thread()` — only for these 5 approved touch-points:
   - LangFuse SDK (no async version)
   - Gmail OAuth (inherently blocking)
   - SQLAlchemy DDL at startup
   - Cleanup job entry point
   - Pure CPU helpers with no I/O
7. **Do NOT add new sync touch-points** — check `docs/Mirix_async_native_changes.md` first

### Project-Specific Patterns

#### 1. Memory System Architecture
- **Meta Agent** orchestrates specialized memory agents
- **Sub-agents** extract specific memory types (episodic, semantic, etc.)
- **Memory extraction** happens via queue-worker architecture
- Each memory type has dedicated ORM models, schemas, and managers

#### 2. Database Patterns
- **ORM Models**: Located in `mirix/orm/` using SQLAlchemy
- **Schemas**: Located in `mirix/schemas/` using Pydantic
- **Managers**: Located in `mirix/services/` for business logic
- Always use `OrganizationMixin`, `UserMixin`, `AgentMixin` where applicable

#### 3. Agent Execution Flow
- `step()` method is the main agent execution loop (like LangChain's AgentExecutor)
- `inner_step()` handles single LLM interactions with tool calls
- `save_agent()` persists agent state to database
- Steps are logged to the `steps` table for audit/analytics (write-only)

#### 4. Message Flow
- Queue messages (transient) != Database messages (persistent)
- Database messages stored via `MessageManager.create()` after agent execution
- Messages link to steps via `step_id` foreign key
- Messages table used for conversation history and search

#### 5. API Patterns
- REST endpoints in `mirix/server/rest_api.py`
- Client SDK in `mirix/client/remote_client.py`
- Always authenticate with JWT or API key
- Use `create_or_get_user()` to ensure user exists before operations

#### 6. Settings Management
- Environment variables defined in `mirix/settings.py`
- Use Pydantic BaseSettings with `env` prefix `MIRIX_`
- Provider API keys in `ModelSettings`
- Tool configs in `ToolSettings`

#### 7. Tool Execution
- User-defined tools run in `ToolExecutionSandbox` for security
- Tools defined in `mirix/functions/function_sets/`
- Memory tools in `memory_tools.py`, base tools in `base.py`

### Code Review Checklist
Before suggesting changes, verify:
- [ ] No duplicate code or configurations
- [ ] Type hints are present and correct
- [ ] Error handling is specific and informative
- [ ] Docstrings follow PEP 257
- [ ] No hardcoded secrets or API keys
- [ ] Database operations use proper ORM patterns
- [ ] Async functions are properly awaited
- [ ] Tests are included for new functionality
- [ ] Logging uses appropriate levels (debug, info, warning, error)

### Common Pitfalls to Avoid
1. **Do NOT** confuse queue messages with database messages
2. **Do NOT** call `step_manager.get_step()` - steps are write-only audit logs
3. **Do NOT** bypass `create_or_get_user()` - always ensure users exist first
4. **Do NOT** create agents without proper `CreateAgent` schema objects
5. **Do NOT** forget to persist agent state with `save_agent()`
6. **Do NOT** use `message.step` relationship - it's never loaded in practice
7. **Do NOT** add duplicate environment variables in settings.py

### Testing Guidelines
- Tests located in `tests/` directory
- Use pytest fixtures defined in `conftest.py`
- Mock external LLM calls in tests
- Test user isolation, memory extraction, and API endpoints
- Run tests with: `pytest tests/`

### Documentation
- Do NOT create documentation files unless explicitly requested
- Do NOT create README files proactively
- Update existing docs when making significant architectural changes
- Keep code comments concise and focused on WHY

### Git Workflow
- Commit messages should be clear and descriptive
- Run linters before committing: `ruff check .` and `pyright`
- Resolve merge conflicts carefully (especially in `poetry.lock`)
- Do NOT commit secrets or API keys

### File Organization
```
mirix/
├── agent/          # Agent implementations (MetaAgent, SubAgents)
├── client/         # Client SDK (remote_client.py, client.py)
├── database/       # Database connectors (PostgreSQL, Redis)
├── functions/      # Tool definitions and function sets
├── llm_api/        # LLM provider integrations
├── orm/            # SQLAlchemy ORM models
├── queue/          # Message queue (Kafka) implementation
├── schemas/        # Pydantic schemas for validation
├── server/         # FastAPI REST API (rest_api.py, server.py)
├── services/       # Business logic managers (user, agent, memory)
├── prompts/        # System prompts for agents
└── settings.py     # Environment configuration
```

### When Analyzing Code
1. Always trace from ORM models → Schemas → Managers → APIs
2. Check both where code is defined AND where it's called
3. Distinguish between operational flow and audit logging
4. Verify parameter signatures match between callers and callees
5. Understand the meta-agent → sub-agent orchestration pattern

### Performance Considerations
- Use bulk operations for database writes when possible
- Leverage Redis caching for frequently accessed data
- Monitor LLM token usage and costs
- Use async patterns for I/O-bound operations
- Consider queue backpressure for high-throughput scenarios

### Security Best Practices
- User-defined tools MUST run in `ToolExecutionSandbox`
- Validate all user inputs with Pydantic schemas
- Use parameterized queries (ORM handles this)
- Sanitize log messages (no sensitive data)
- Implement proper authentication and authorization

## Response Style
- Be concise and clear
- Provide code examples when helpful
- Reference specific files and line numbers
- Explain complex logic flows step-by-step
- Don't make changes unless explicitly requested
- Ask clarifying questions when intent is ambiguous

mirix-personal-memory-agent/.editorconfigtext · 0.7 KB

# EditorConfig is awesome: https://EditorConfig.org

# top-most EditorConfig file
root = true

# Unix-style newlines with a newline ending every file
[*]
end_of_line = lf
insert_final_newline = true
charset = utf-8
trim_trailing_whitespace = true

# Python files
[*.py]
indent_style = space
indent_size = 4
max_line_length = 120

# YAML files
[*.{yml,yaml}]
indent_style = space
indent_size = 2

# JSON files
[*.json]
indent_style = space
indent_size = 2

# Markdown files
[*.md]
trim_trailing_whitespace = false
max_line_length = off

# Shell scripts
[*.sh]
indent_style = space
indent_size = 4

# Makefile
[Makefile]
indent_style = tab

# Dockerfile
[Dockerfile*]
indent_style = space
indent_size = 4

mirix-personal-memory-agent/.github/workflows/tests.ymlcode · 3.2 KB

name: Tests

on:
  push:
    branches: [ main, master, dev, re-org, production ]
  pull_request:
    branches: [ main, master, dev, re-org, production ]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        python-version: ['3.12']

    steps:
    - uses: actions/checkout@v4

    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v5
      with:
        python-version: ${{ matrix.python-version }}

    - name: Cache pip packages
      uses: actions/cache@v4
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: ${{ runner.os }}-pip-

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -e .
        pip install pytest pytest-cov python-dotenv requests pyyaml pytest-asyncio

    - name: Verify workspace structure
      run: |
        echo "Current directory: ${{ github.workspace }}"
        ls -la
      shell: bash

    - name: Run unit/in-process tests (no server required)
      run: |
        cd "${{ github.workspace }}"
        python -m pytest tests/test_memory_server.py \
               tests/test_auth_provider.py \
               tests/test_queue.py \
               tests/test_redis_integration.py -v
      shell: bash
      env:
        GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

    - name: Start API server
      if: matrix.os != 'windows-latest'
      run: |
        python scripts/start_server.py --port 8000 --log-level warning &
        sleep 8
        curl --retry 5 --retry-delay 3 --retry-all-errors http://localhost:8000/health
      shell: bash
      env:
        GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

    - name: Run API/integration tests
      if: matrix.os != 'windows-latest'
      run: |
        cd "${{ github.workspace }}"
        python -m pytest \
          tests/test_memory_integration.py \
          tests/test_agent_prompt_update.py \
          tests/test_client_agent_isolation.py \
          tests/test_deletion_apis.py \
          tests/test_temporal_queries.py \
          tests/test_user.py -v
      shell: bash
      env:
        GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
      continue-on-error: true

    - name: Generate coverage (Ubuntu + Python 3.12 only)
      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
      run: |
        cd "${{ github.workspace }}"
        python -m pytest tests/test_memory_server.py --cov=mirix --cov-report=html --cov-report=term
      shell: bash
      continue-on-error: true

    - name: Upload coverage report
      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
      uses: actions/upload-artifact@v4
      with:
        name: coverage-report
        path: htmlcov/
      continue-on-error: true

mirix-personal-memory-agent/.gitignoretext · 0.6 KB

test
__pycache__
tmp
.env
storage
responses
collected_images
google_file*
debug
node_modules/
frontend/node_modules
frontend/dist
frontend/backend
dist/
build/
*.egg-info/
.env.*
.DS_Store
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
coverage/
.parcel-cache/
.next/
.nuxt/
.vite/
.eslintcache
local_test
results/
data/
mirix_env/
local_evaluations
.claude/
mirix.egg-info
.local

# Testing
.pytest_cache/
htmlcov/
.coverage
.coverage.*
*.cover
.hypothesis/
.tox/
*.db
*.sqlite
*.sqlite-journal
test-results/
test_*.db
*.log
.persist

mirix-personal-memory-agent/.vscode/extensions.jsoncode · 0.1 KB

{
  "recommendations": [
    "ms-python.python",
    "ms-python.black-formatter",
    "ms-python.mypy-type-checker"
  ]
}

mirix-personal-memory-agent/.vscode/settings.jsoncode · 1.7 KB

{
  // IMPORTANT: Workspace settings override user settings automatically in VS Code/Cursor
  // These settings ensure consistent formatting across all team members

  // Format on save - REQUIRED for consistency
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.organizeImports": "explicit"
  },

  // Python interpreter: Use Poetry's virtual environment
  // This ensures all Python tools (including Black Formatter) use the Poetry environment
  "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",

  // Python linting - mypy
  "python.linting.enabled": true,
  "python.linting.mypyEnabled": true,
  "python.linting.mypyArgs": [
    "--config-file=pyproject.toml"
  ],

  // File associations - Python files use Black
  "[python]": {
    "editor.defaultFormatter": "ms-python.black-formatter",
    "editor.formatOnSave": true,
    "editor.rulers": [120],
    "editor.tabSize": 4,
    "editor.insertSpaces": true
  },

  // Black Formatter: Use extension's bundled Black with explicit settings
  // Explicitly match command-line Black settings to ensure consistency
  // Line length 120 matches pyproject.toml [tool.black] line-length = 120
  "black-formatter.args": [
    "--line-length",
    "120"
  ],
  // Note: Extension uses its bundled Black version, but with matching line-length
  // Minor formatting differences may still occur due to version differences

  // Global editor settings
  "editor.trimAutoWhitespace": true,
  "files.insertFinalNewline": true,
  "files.trimTrailingWhitespace": true,
  "files.eol": "\n",

  // Exclude patterns from file explorer
  "files.exclude": {
    "**/__pycache__": true,
    "**/*.pyc": true,
    "**/.mypy_cache": true,
    "**/.pytest_cache": true
  }
}

mirix-personal-memory-agent/CLA.mdmarkdown · 4.7 KB
This Contributor License Agreement (“Agreement”) is entered into by the individual or entity signing below (“You”) and Yu Wang (the “MIRIX Project Owner”), effective as of the latest signature date below.

The purpose of this Agreement is to clarify the intellectual-property rights granted by You to the MIRIX Project, administered by Yu Wang, and to ensure that the MIRIX Project Owner retains full rights to use, modify, and commercialize the MIRIX open-source project.

1. Definitions
- Contribution – Any original work of authorship, including source code, documentation, or other material, that You submit to the MIRIX Project for inclusion in or documentation of the project.
- Project – The MIRIX open-source project, administered by Yu Wang and released under an Open Source Initiative (OSI)–approved license.
- Submit – The act of uploading, transmitting, or distributing a Contribution to a MIRIX repository or communication channel for the purpose of improving, discussing, or maintaining the Project.
2. Ownership and Grant of License

a. Your Rights

You retain ownership of all intellectual-property rights in your Contributions.

b. License to MIRIX Project Owner

You hereby grant Yu Wang (the MIRIX Project Owner) a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license to:
1. Use, reproduce, modify, prepare derivative works of, publicly display, publicly perform, sublicense, distribute, and commercialize your Contributions;
2. Incorporate your Contributions into MIRIX products, services, or derivative works (including commercial offerings and enterprise deployments); and
3. Sublicense these rights to third parties as necessary for the MIRIX Project’s business or distribution activities.
This license includes the right for the MIRIX Project Owner to use your Contributions in both open-source and commercial contexts.

c. No Reciprocal Commercial Rights

You acknowledge and agree that this Agreement does not grant You or Your employer any right to commercially use, distribute, or license the MIRIX Project, its derivatives, or associated trademarks, except as expressly permitted in writing by Yu Wang (the MIRIX Project Owner).

3. Representations and Warranties

You represent that:
1. Each of your Contributions is your original work, or you have the right to submit it.
2. You have secured all necessary permissions from your employer or other third parties.
3. Your Contribution does not violate any third-party rights.
4. You have the authority to enter into this Agreement.
4. Patent License

You grant the MIRIX Project Owner a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license under your patent claims that are necessarily infringed by your Contribution or by the combination of your Contribution with the Project, to make, use, sell, offer to sell, import, and otherwise distribute the Contribution and derivative works thereof.

5. Disclaimer of Warranty

Unless required by law or agreed in writing, your Contribution is provided “AS IS” without warranties or conditions of any kind, including warranties of title, non-infringement, merchantability, or fitness for a particular purpose.

6. Public Record

You understand and agree that your name, employer (if applicable), and details of your Contribution may be publicly listed as part of the MIRIX Project’s contribution history.

7. Governing Law

This Agreement will be governed by and construed under the laws of the State of California, without regard to conflict-of-laws principles. You consent to exclusive jurisdiction in the state and federal courts located in San Francisco County, California.

8. Entire Agreement

This Agreement constitutes the entire understanding between You and Yu Wang (the MIRIX Project Owner) concerning Contributions to the MIRIX Project and supersedes any prior agreements.

Signature Section

Please select one of the following and sign below:

A. Individual Contributor

I am contributing in my personal capacity and retain sole ownership of my intellectual-property rights.

Field Information
Name
Signature
Date
GitHub Login
Email

B. Corporate Contributor

I am contributing on behalf of my employer or entity, and have authority to bind my employer to this Agreement. All rights granted here apply collectively to me and my employer.

Field Information
Company Name
Representative Name
Title
Signature
Date
GitHub Login
Email

© 2025 mirix.io. All Rights Reserved.
mirix-personal-memory-agent/CLAUDE.mdmarkdown · 3.4 KB
MIRIX - Claude Code Instructions

What This Project Does

MIRIX is an async-native multi-agent personal assistant with a six-component memory system (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault). It captures memories from conversations and screen activity, storing them in PostgreSQL with vector search via pgvector.

Key Architecture
- Entry point: mirix/server/rest_api.py (FastAPI, port 8531)
- Orchestration: mirix/agent/meta_agent.py → 6 sub-agents
- Data flow: ORM (mirix/orm/) → Schemas (mirix/schemas/) → Managers (mirix/services/) → API (mirix/server/)
- Queue: Kafka-backed (mirix/queue/) for async memory extraction
- All I/O is async — never introduce sync blocking calls (see docs/Mirix_async_native_changes.md)
Local Development Setup

Prerequisites
- Docker + Docker Compose
- Python 3.10+
- At least one LLM API key (OpenAI, Anthropic, or Google Gemini)
Start Infrastructure
```
cp docker/env.example .env   # then add your API keys to .env
docker-compose up -d         # starts PostgreSQL (5432), Redis (6379), API (8531), Dashboard (5173)
docker-compose ps            # verify all services healthy
```
Run API Locally (without Docker)
```
pip install -e .
export GEMINI_API_KEY=your-key   # or OPENAI_API_KEY / ANTHROPIC_API_KEY
python scripts/start_server.py --port 8531
```
Access Points
- Dashboard: http://localhost:5173
- API Swagger: http://localhost:8531/docs
- API ReDoc: http://localhost:8531/redoc
Running Tests
```
# Fast unit tests — no running server needed (~20s)
pytest tests/test_memory_server.py -v

# All tests except integration
pytest -m "not integration" -v

# Integration tests — requires server on port 8899
python scripts/start_server.py --port 8899          # Terminal 1
pytest tests/test_memory_integration.py -v -m integration -s   # Terminal 2

# Full suite
pytest -v
```
Required env var for tests: GEMINI_API_KEY

Common Dev Tasks

Add a new API endpoint
1. Add Pydantic request/response schemas to mirix/schemas/
2. Add business logic method to the relevant manager in mirix/services/
3. Add the route to mirix/server/rest_api.py
4. Add the corresponding method to mirix/client/remote_client.py
Add a new memory type
1. Create ORM model in mirix/orm/
2. Create Pydantic schemas in mirix/schemas/
3. Create manager in mirix/services/
4. Create sub-agent in mirix/agent/
5. Register in mirix/agent/meta_agent.py
Format & lint
```
make format   # ruff import sort + format
make lint     # ruff check + pyright
make check    # format + lint + test
```
Async Rules (Critical)
- All new manager methods must be async def
- Never use asyncio.run() inside the server — the event loop is already running
- Only 5 intentional sync touch-points exist (LangFuse, Gmail OAuth, SQLAlchemy DDL at startup, cleanup job entry, pure CPU helpers) — do not add more
- Use asyncio.to_thread() to wrap any unavoidably sync third-party calls
Commit Convention

Prefix commits with the Jira ticket: [VEPEAGE-NNN] Description

Do Not
- Confuse queue messages (transient) with database messages (persistent)
- Call step_manager.get_step() — steps are write-only audit logs
- Skip create_or_get_user() — always ensure users exist first
- Commit secrets or API keys
- Create README or doc files unless explicitly requested
mirix-personal-memory-agent/CODE_OF_CONDUCT.mdmarkdown · 5.1 KB
Contributor Covenant Code of Conduct

Our Pledge

We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.

Our Standards

Examples of behavior that contributes to a positive environment for our community include:
- Demonstrating empathy and kindness toward other people
- Being respectful of differing opinions, viewpoints, and experiences
- Giving and gracefully accepting constructive feedback
- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
- Focusing on what is best not just for us as individuals, but for the overall community
Examples of unacceptable behavior include:
- The use of sexualized language or imagery, and sexual attention or advances of any kind
- Trolling, insulting or derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or email address, without their explicit permission
- Other conduct which could reasonably be considered inappropriate in a professional setting
Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive,or harmful.

Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.

Scope

This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.

Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at founders@mirix.io. All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the reporter of any incident.

Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. Correction

Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.

Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.

2. Warning

Community Impact: A violation through a single incident or series of actions.

Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. Temporary Ban

Community Impact: A serious violation of community standards, including sustained inappropriate behavior.

Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. Permanent Ban

Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.

Consequence: A permanent ban from any sort of public interaction within the community.

Attribution

This Code of Conduct is adapted from the Contributor Covenant, version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
mirix-personal-memory-agent/CODE_STANDARDS.mdmarkdown · 3.1 KB
MIRIX Code Standards

Code Formatting and Style

MIRIX follows PEP 8 style guidelines with some project-specific modifications. We use automated tools to ensure consistency across the codebase.

Formatting Tools
- Black: Code formatter (configured in pyproject.toml)
- isort: Import sorter (configured to work with Black)
- mypy: Static type checker
- Ruff: Fast Python linter
- Pyright: Type checker
Style Guidelines
- Indentation: Use 4 spaces per indentation level. Never use tabs.
- Line Length: Maximum 120 characters (configured in Black and isort)
- Blank Lines:
  - Two blank lines to separate top-level functions and classes
  - One blank line to separate methods within a class
- Imports:
  - Place all import statements at the top of the file
  - Group imports: standard library, third-party, local application (with blank lines between groups)
  - Use isort to automatically organize imports (configured with Black profile)
- Naming Conventions:
  - Variables and Functions: snake_case (lowercase with underscores)
  - Classes: CamelCase (each word capitalized)
  - Constants: ALL_CAPS_WITH_UNDERSCORES
- Whitespace: Use spaces around operators and after commas, but not directly inside parentheses or brackets
- Comments: Use inline comments sparingly. They should explain why, not what. Separate inline comments from statements by at least two spaces
- Docstrings: Use triple double quotes (""") for docstrings. Clearly describe the purpose of modules, classes, and functions
Editor Configuration

The repository includes configuration files to ensure consistent formatting:
- .editorconfig: Defines basic editor settings (indentation, line endings, etc.)
- .vscode/settings.json: VS Code/Cursor settings for automatic formatting with Black
- pyproject.toml: Contains Black, isort, and mypy configuration
Running Formatting Tools

Note: This project uses Poetry for dependency management. Use poetry run to ensure correct versions.
```
# Format code with Black
poetry run black .

# Sort imports with isort
poetry run isort .

# Type check with mypy
poetry run mypy mirix/

# Lint with Ruff
poetry run ruff check .
```
IDE Setup

For VS Code/Cursor users, the .vscode/settings.json file configures:
- Black as the default formatter (uses Poetry's Black installation, version 25.11.0)
- Format on save enabled
- Automatic import organization
- mypy type checking
Make sure you have the following extensions installed:
- Python extension (ms-python.python)
- Black Formatter extension (ms-python.black-formatter)
Important:
- Select the Poetry virtual environment as your Python interpreter (Cmd+Shift+P -> "Python: Select Interpreter")
- The editor uses Poetry's Black installation (via black-formatter.importStrategy: "fromEnvironment")
- This ensures editor formatting matches poetry run black command-line formatting
mirix-personal-memory-agent/CONTRIBUTING.mdmarkdown · 8.0 KB
Contributing to MIRIX

We’re thrilled to have you join us in contributing to MIRIX! As passionate champions of open-source collaboration, we’re committed to building not only a powerful tool but also a vibrant community where developers of all skill levels can make impactful contributions. Before you get started, we encourage you to review the MIRIX Code Standards. This will help ensure consistency and set the stage for success for everyone involved.

Our contribution pathways are designed to make it easy for you to get involved and start making an impact immediately:

Four Ways to Get Involved

Help With Existing Issues

Our developers frequently tag issues with "help wanted" and "good first issue," highlighting pre-vetted tasks with a clear scope. Plus, there's always someone available to assist you if you encounter any challenges along the way.

Create Your Own Tickets

Noticed something that needs fixing? Got an idea for an improvement? You don’t need permission to identify problems—the people closest to the pain are often the best equipped to envision solutions.

For feature requests, share the story of what you’re trying to achieve. What are you working on? What’s standing in your way? What would make your life easier? Submit your ideas through our GitHub issue tracker using the "Feature Request" label.

For bug reports, it’s important to provide enough details for us to reproduce the issue. Use our GitHub issue tracker and include the following:
- A clear and concise title summarizing the problem
- What you were attempting to do when the issue occured
- What you expected to happen versus what actually happened
- A code sample, test case, or detailed steps to help us replicate the issue
Share Your Use Cases

Not all contributions are about writing code—sometimes the most impactful ones come from sharing how you're using our project. If you're leveraging MIRIX in an interesting way, consider adding it to the samples folder. This not only helps others explore new possibilities but also counts as a meaningful contribution. We often highlight compelling examples in our blog posts and videos, so your work could be showcased to the broader community!

Help Others in Discord

Join our Discord community and contribute by lending a hand at the helpdesk. Answering questions and helping troubleshoot issues is an invaluable way to support the community. The knowledge you share today could save someone hours of frustration tomorrow.

What happens next?

Notes for Large Changes

Please keep changes as concise as possible. For major architectural changes (>500 LOC), please create a GitHub issue (RFC) to discuss the technical design and justification. Otherwise, we may tag it as "rfc-required" and potentially not review the PR.

Once you've identified an issue tagged with "good first issue" or "help wanted," or have an example you'd like to share, here's how to turn it into a contribution:
1. Share your proposed approach in the issue discussion or on Discord before diving into the code. This ensures your solution aligns with MIRIX's architecture from the outset and helps avoid potential rework.
2. Fork the repository, create a branch for your changes, and submit a pull request (PR). Detailed technical instructions are provided below — be open to feedback during the review process.
Setup
1. Fork the repository on GitHub.
2. Clone your fork locally:
```
git clone https://github.com/Mirix-AI/MIRIX
cd MIRIX
```
3. Set up your development environment:
  
  Follow the "Development Installation" section in this Get Started document.
  
  If you prefer to poetry instead of pip, follow these additional steps. (uv follows similar steps)
  - Ensure you have Python 3.11+ installed.
  - Install poetry: https://python-poetry.org/docs/
  - [Recommended] Configure poetry to create virtual env under your current project
    poetry config virtualenvs.in-project true
  - Install project dependencies:
    make install
Making Changes
1. Create a new branch for your changes:
```
git checkout -b your-branch-name
```
2. Make your changes in the codebase.
3. Write or update tests as necessary.
4. Run the tests to ensure they pass:
```
make test
```
5. Format your code:
```
make format
```
6. Run linting checks:
```
make lint
```
Submitting Changes
1. Commit your changes:
```
git commit -m "Your commit message"
```
2. Push to your fork:
```
git push origin your-branch-name
```
3. Submit a pull request through the GitHub website to https://github.com/Mirix-AI/MIRIX.
Pull Request Guidelines
- Provide a clear title and description of your changes.
- Include any relevant issue numbers in the PR description.
- Ensure all tests pass and there are no linting errors.
- Update documentation if you're changing functionality.
Code Style and Quality

We use several tools to maintain code quality:
- Ruff for linting and formatting
- Pyright for static type checking
- Pytest for testing
Before submitting a pull request, please run:
```
make check
```
This command will format your code, run linting checks, and execute tests.

Third-Party Integrations

When contributing integrations for third-party services (LLM providers, embedding services, databases, etc.), please follow these patterns:

Optional Dependencies

All third-party integrations must be optional dependencies to keep the core library lightweight. Follow this pattern:
1. Add to pyproject.toml: Define your dependency as an optional extra AND include it in the dev extra:
```
[project.optional-dependencies]
your-service = ["your-package>=1.0.0"]
dev = [
    # ... existing dev dependencies
    "your-package>=1.0.0",  # Include all optional extras here
    # ... other dependencies
]
```
2. Use TYPE_CHECKING pattern: In your integration module, import dependencies conditionally:
```
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    import your_package
    from your_package import SomeType
else:
    try:
        import your_package
        from your_package import SomeType
    except ImportError:
        raise ImportError(
            'your-package is required for YourServiceClient. '
            'Install it with: pip install MIRIX[your-service]'
        ) from None
```
3. Benefits of this pattern:
  - Fast startup times (no import overhead during type checking)
  - Clear error messages with installation instructions
  - Proper type hints for development
  - Consistent user experience
4. Do NOT:
  - Add optional imports to __init__.py files
  - Use direct imports without error handling
  - Include optional dependencies in the main dependencies list
Integration Structure
- Place LLM clients in mirix/llm_client/
- Place embedding clients in mirix/embedder/
- Place database drivers in mirix/driver/
- Place database script python files in database/
- Place samples in samples/
- Follow existing naming conventions (e.g., your_service_client.py)
Testing
- Add comprehensive tests in the appropriate tests/ subdirectory
- Mark integration tests with _int suffix if they require external services
- Include both unit tests and integration tests where applicable
Questions?

Stuck on a contribution or have a half-formed idea? Come say hello in our Discord server. Whether you're ready to contribute or just want to learn more, we're happy to have you! It's faster than GitHub issues and you'll find both maintainers and fellow contributors ready to help.

Thank you for your contribution to MIRIX!

Field	Information
Name
Signature
Date
GitHub Login
Email

Field	Information
Company Name
Representative Name
Title
Signature
Date
GitHub Login
Email

mirix-personal-memory-agent/Dockerfiletext · 2.1 KB

# ============================================================================
# Mirix Backend Dockerfile
# ============================================================================
# Multi-stage build for optimal image size and security
# ============================================================================

# Stage 1: Builder
FROM python:3.11-slim as builder

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# Install build dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# Create virtual environment
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

# Copy requirements and install dependencies
WORKDIR /app
COPY requirements.txt .
RUN pip install --upgrade pip && \
    pip install -r requirements.txt

# Stage 2: Runtime
FROM python:3.11-slim as runtime

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PATH="/opt/venv/bin:$PATH" \
    # Default Mirix settings
    MIRIX_DIR=/app/data \
    MIRIX_IMAGES_DIR=/app/data/images \
    MIRIX_LOG_LEVEL=INFO \
    MIRIX_LOG_TO_CONSOLE=true

# Install runtime dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    libpq5 \
    ffmpeg \
    curl \
    && rm -rf /var/lib/apt/lists/* \
    && useradd --create-home --shell /bin/bash mirix

# Copy virtual environment from builder
COPY --from=builder /opt/venv /opt/venv

# Set working directory
WORKDIR /app

# Copy application code
COPY --chown=mirix:mirix mirix/ ./mirix/
COPY --chown=mirix:mirix pyproject.toml ./
COPY --chown=mirix:mirix README.md ./

# Create data directories
RUN mkdir -p /app/data/images && chown -R mirix:mirix /app/data

# Switch to non-root user
USER mirix

# Expose port
EXPOSE 8531

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
    CMD curl -f http://localhost:8531/health || exit 1

# Default command - run the FastAPI server
CMD ["uvicorn", "mirix.server.rest_api:app", "--host", "0.0.0.0", "--port", "8531"]

mirix-personal-memory-agent/LICENSEtext · 10.5 KB

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   Copyright 2023, Letta authors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

mirix-personal-memory-agent/MANIFEST.intext · 2.0 KB

# Include the README and LICENSE
include README.md
include LICENSE

# Include configuration files
recursive-include configs *.yaml *.yml
recursive-include mirix/configs *.yaml *.yml

# Include prompt templates
recursive-include mirix/prompts *.txt *.yaml *.yml

# Include any schema files
recursive-include mirix/schemas *.json *.yaml *.yml

# Include assets for the package
recursive-include assets *.png *.jpg *.jpeg *.gif *.ico

# Exclude development and build files
global-exclude *.pyc
global-exclude *.pyo
global-exclude *.pyd
global-exclude __pycache__
global-exclude .DS_Store
global-exclude *.so
global-exclude .git*

# Exclude frontend and other non-Python directories
prune frontend
prune public_evaluations
prune scripts
prune mirix_env
prune test_mirix_env
prune dashboard
prune .git

# Drop any remaining content from pruned directories in sdist
recursive-exclude dashboard *
recursive-exclude test_mirix_env *
recursive-exclude scripts *
recursive-exclude frontend *
recursive-exclude public_evaluations *
recursive-exclude tmp *
recursive-exclude samples *
recursive-exclude assets *
recursive-exclude debug *

# Exclude server-side Python packages from sdist
prune mirix/agent
prune mirix/server
prune mirix/services
prune mirix/queue
prune mirix/llm_api
prune mirix/orm
prune mirix/local_client
prune mirix/functions
prune mirix/prompts
prune mirix/database
prune mirix/temporal
prune mirix/security

# Safety: drop any remaining files under these paths
recursive-exclude mirix/agent *
recursive-exclude mirix/server *
recursive-exclude mirix/services *
recursive-exclude mirix/queue *
recursive-exclude mirix/llm_api *
recursive-exclude mirix/orm *
recursive-exclude mirix/local_client *
recursive-exclude mirix/functions *
recursive-exclude mirix/prompts *
recursive-exclude mirix/database *
recursive-exclude mirix/temporal *
recursive-exclude mirix/security *
recursive-exclude mirix/configs *

# Exclude test files
prune tests
global-exclude test_*.py
global-exclude *_test.py

# Exclude build artifacts
prune build
prune dist
prune *.egg-info

mirix-personal-memory-agent/Makefiletext · 0.5 KB

.PHONY: install format lint test all check

# Define variables
PYTHON = python3
POETRY = poetry
PYTEST = $(POETRY) run pytest
RUFF = $(POETRY) run ruff
PYRIGHT = $(POETRY) run pyright

# Default target
all: format lint test

# Install dependencies
install:
	$(POETRY) install

# Format code
format:
	$(RUFF) check --select I --fix
	$(RUFF) format

# Lint code
lint:
	$(RUFF) check --fix
	$(PYRIGHT) .

# Run tests
test:
	$(PYTEST)

# Run format, lint, and test
check: format lint test

mirix-personal-memory-agent/PR_DESCRIPTION_MIRIX.mdmarkdown · 6.6 KB

Add JSON Serialization and SSL/TLS Support for Kafka Queue

📋 Summary

This PR adds JSON serialization and SSL/TLS support to MIRIX's Kafka queue implementation, enabling integration with Intuit Event Bus while maintaining 100% backward compatibility with existing Protobuf serialization.

🎯 Motivation

Context and Memory Service (ECMS) is integrating with Intuit Event Bus, which requires:

✅ JSON message format (Event Bus standard)
✅ mTLS authentication (production security requirement)

Current State: MIRIX Kafka queue only supports:

❌ Protobuf binary serialization (incompatible with Event Bus)
❌ PLAINTEXT connections (no production-ready security)

This PR enables:

✅ JSON serialization (Event Bus compatible)
✅ SSL/TLS with mTLS (production ready)
✅ Configurable via environment variables
✅ 100% backward compatible (Protobuf + PLAINTEXT remain defaults)

📁 Files Changed (3 files)

1. `mirix/queue/config.py`

Added 5 new environment variables:

# Serialization format
KAFKA_SERIALIZATION_FORMAT = os.environ.get("KAFKA_SERIALIZATION_FORMAT", "protobuf")

# SSL/TLS configuration
KAFKA_SECURITY_PROTOCOL = os.environ.get("KAFKA_SECURITY_PROTOCOL", "PLAINTEXT")
KAFKA_SSL_CAFILE = os.environ.get("KAFKA_SSL_CAFILE")
KAFKA_SSL_CERTFILE = os.environ.get("KAFKA_SSL_CERTFILE")
KAFKA_SSL_KEYFILE = os.environ.get("KAFKA_SSL_KEYFILE")

Why: Provides configuration interface for JSON and SSL features

2. `mirix/queue/kafka_queue.py`

Added:

json_serializer() - Converts Protobuf → JSON → bytes
json_deserializer() - Converts bytes → JSON → Protobuf
New constructor parameters:
- serialization_format: str = 'protobuf'
- security_protocol: str = 'PLAINTEXT'
- ssl_cafile, ssl_certfile, ssl_keyfile (Optional)
Format selection logic (JSON vs Protobuf)
SSL configuration for KafkaProducer/KafkaConsumer

Why: Implements JSON serialization and SSL/TLS support

Example Flow:

QueueMessage (Protobuf) 
  → json_serializer() 
  → JSON string 
  → bytes 
  → Kafka
  → bytes 
  → json_deserializer() 
  → QueueMessage (Protobuf)

3. `mirix/queue/manager.py`

Updated _create_queue() to:

Build kwargs dict with serialization format and SSL parameters
Pass all config to KafkaQueue(**kwargs)
Conditionally add SSL params only if provided

Why: Connects config → KafkaQueue initialization

🚀 Usage Examples

Scenario 1: Local Development (PLAINTEXT + JSON)

export QUEUE_TYPE=kafka
export KAFKA_BOOTSTRAP_SERVERS=localhost:9092
export KAFKA_SERIALIZATION_FORMAT=json
export KAFKA_SECURITY_PROTOCOL=PLAINTEXT

Result: JSON messages on local Docker Kafka

Scenario 2: E2E/Prod Event Bus (SSL + JSON)

export QUEUE_TYPE=kafka
export KAFKA_BOOTSTRAP_SERVERS=broker1:9094,broker2:9094
export KAFKA_SERIALIZATION_FORMAT=json
export KAFKA_SECURITY_PROTOCOL=SSL
export KAFKA_SSL_CAFILE=/tmp/ca.pem
export KAFKA_SSL_CERTFILE=/tmp/cert.pem
export KAFKA_SSL_KEYFILE=/tmp/key.pem

Result: JSON messages on secure Kafka with mTLS

Scenario 3: Default (Unchanged Behavior)

export QUEUE_TYPE=kafka
export KAFKA_BOOTSTRAP_SERVERS=localhost:9092
# No KAFKA_SERIALIZATION_FORMAT → defaults to protobuf
# No KAFKA_SECURITY_PROTOCOL → defaults to PLAINTEXT

Result: Protobuf messages on PLAINTEXT Kafka (existing behavior)

📊 Message Format Comparison

Protobuf (Default)

Binary: \x0a\x10client-uuid\x12\x05agent\x1a\x04user...
Size: ~250 bytes (compact)
Human-readable: ❌ No
Event Bus compatible: ❌ No

JSON (New)

{
  "client_id": "client-d18089e4-3b28-43ed-b45b-53bdfeac82cb",
  "agent_id": "agent-3e229396-d7d1-4b0f-81d6-12f7ce2eb4d5",
  "user_id": "9411863178471709",
  "actor": {
    "id": "9411863178471709",
    "type": "USER"
  },
  "messages": [
    {
      "role": "USER",
      "content": "What is QuickBooks?"
    }
  ],
  "timestamp": "2026-01-08T08:31:03.020080"
}

Size: ~400 bytes (larger but readable)
Human-readable: ✅ Yes
Event Bus compatible: ✅ Yes
Kafka UI compatible: ✅ Yes (can view in browser)

✅ Testing

Tested locally with ECMS:

✅ Local Kafka (Docker) with JSON + PLAINTEXT
✅ Messages successfully produced and consumed
✅ Verified in Kafka UI (JSON visible in browser)
✅ ECMS /v1/memories endpoint → Kafka → MIRIX worker processing

Backward Compatibility:

✅ Default Protobuf behavior unchanged
✅ Existing deployments continue to work
✅ No breaking changes

🔄 Backward Compatibility

Aspect	Before	After	Breaking?
Default serialization	Protobuf	Protobuf	❌ No
Default security	PLAINTEXT	PLAINTEXT	❌ No
Config required?	Yes	Yes	❌ No
JSON support	❌ No	✅ Yes	➕ Feature
SSL support	❌ No	✅ Yes	➕ Feature

Conclusion: 100% backward compatible - all changes are opt-in via environment variables.

🎯 ECMS Integration

This PR enables ECMS to integrate with Intuit Event Bus by:

ECMS sets environment variables (common/mirix_adapter.py):

os.environ["KAFKA_SERIALIZATION_FORMAT"] = "json"
os.environ["KAFKA_SECURITY_PROTOCOL"] = "SSL"
# ... SSL cert paths from IDPS

MIRIX reads config (mirix/queue/config.py):

KAFKA_SERIALIZATION_FORMAT = "json"
KAFKA_SECURITY_PROTOCOL = "SSL"

MIRIX creates Kafka queue (mirix/queue/manager.py):

KafkaQueue(serialization_format="json", security_protocol="SSL", ...)

Messages flow to Event Bus in JSON format with mTLS!

📦 Versioning

Version will be set at publish time:

python scripts/packaging/setup_server.py \
    --package-name jl-ecms-server \
    --version 0.20.0 \
    sdist bdist_wheel

Targeting: 0.20.x (per Lucas's guidance to avoid conflicts with his 0.19.x work)

Package: jl-ecms-server==0.20.0

🔗 Related Links

ECMS Kafka Integration PR: https://github.intuit.com/expertise-help/context-and-memory-service/pull/43
MIRIX Repo: https://github.com/LiaoJianhe/MIRIX_Intuit (re-org branch)
Event Bus Docs: [Intuit Event Bus Guide]

👥 Reviewers

@LucasParzych @LiaoJianhe

💡 Questions?

Feel free to ask any questions or suggest improvements!

📝 Checklist

Code changes implemented
Backward compatibility maintained
Tested locally with ECMS
No version bump in code (will be set at publish time)
PR description written
Ready for review

mirix-personal-memory-agent/README.mdmarkdown · 10.9 KB

MIRIX - Multi-Agent Personal Assistant with an Advanced Memory System

Your personal AI that builds memory through screen observation and natural conversation

| 🌐 Website | 📚 Documentation | 📄 Paper | 💬 Discord

Key Features 🔥

Multi-Agent Memory System: Six specialized memory components (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) managed by dedicated agents
Screen Activity Tracking: Continuous visual data capture and intelligent consolidation into structured memories
Privacy-First Design: All long-term data stored locally with user-controlled privacy settings
Advanced Search: PostgreSQL-native BM25 full-text search with vector similarity support
Multi-Modal Input: Text, images, voice, and screen captures processed seamlessly

Quick Start

Step 1: Backend & Dashboard (Docker):

docker compose up -d --pull always

Dashboard: http://localhost:5173
API: http://localhost:8531

Step 2: Create an API key in the dashboard (http://localhost:5173) and set as the environmental variable MIRIX_API_KEY.

Step 3: Client (Python, mirix-client, https://pypi.org/project/mirix-client/):

pip install mirix-client

Now you are ready to go! See the example below:

from mirix import MirixClient

client = MirixClient(
    api_key="your-api-key",
    base_url="http://localhost:8531",
)

client.initialize_meta_agent(
    config={
        "llm_config": {
            "model": "gemini-2.0-flash",
            "model_endpoint_type": "google_ai",
            "api_key": "your-api-key-here",
            "model_endpoint": "https://generativelanguage.googleapis.com",
            "context_window": 1_000_000,
        },
        "embedding_config": {
            "embedding_model": "text-embedding-004",
            "embedding_endpoint_type": "google_ai",
            "api_key": "your-api-key-here",
            "embedding_endpoint": "https://generativelanguage.googleapis.com",
            "embedding_dim": 768,
        },
        "meta_agent_config": {
            "agents": [
                {
                    "core_memory_agent": {
                        "blocks": [
                            {"label": "human", "value": ""},
                            {"label": "persona", "value": "I am a helpful assistant."},
                        ]
                    }
                },
                "resource_memory_agent",
                "semantic_memory_agent",
                "episodic_memory_agent",
                "procedural_memory_agent",
                "knowledge_vault_memory_agent",
            ],
        },
    }
)

client.add(
    user_id="demo-user",
    messages=[
        {"role": "user", "content": [{"type": "text", "text": "The moon now has a president."}]},
        {"role": "assistant", "content": [{"type": "text", "text": "Noted."}]},
    ],
    session_id="sess-demo-001",
)

# Include tool activity when you want skills learned from the WORK PROCESS:
# tool errors, retries, and the fix that finally worked are the distiller's
# strongest signals. Pass tool results as role="tool" turns and/or a
# "tool_calls" list on assistant messages (OpenAI shape) — both are preserved
# in the session conversation store.
client.add(
    user_id="demo-user",
    messages=[
        {"role": "user", "content": [{"type": "text", "text": "Deploy the service."}]},
        {"role": "assistant", "content": "", "tool_calls": [
            {"function": {"name": "kubectl_apply", "arguments": "{\"file\": \"deploy.yaml\"}"}}
        ]},
        {"role": "tool", "name": "kubectl_apply", "content": "error: forbidden (missing RBAC)"},
        {"role": "assistant", "content": [{"type": "text", "text": "Fixed the RBAC role and redeployed successfully."}]},
    ],
    session_id="sess-demo-001",
)

memories = client.retrieve_with_conversation(
    user_id="demo-user",
    messages=[
        {"role": "user", "content": [{"type": "text", "text": "What did we discuss on MirixDB in last 4 days?"}]},
    ],
    limit=5,
)
print(memories)

For more API examples, see samples/run_client.py.

Auto-Dream Memory Consolidation

MIRIX also exposes an auto-dream endpoint for explicit memory cleanup and consolidation. Auto-dream reviews existing memories, merges duplicates, resolves stale/conflicting entries where possible, and writes the result back through the memory tools.

REST endpoint:

POST /memory/auto_dream?user_id=demo-user
Content-Type: application/json

{
  "mode": "experience",
  "dry_run": false
}

Supported mode values:

Mode	Memory component(s) reviewed
`core`	Core memory blocks
`episodic`	Episodic memories
`semantic`	Semantic memories
`resource`	Resource memories
`procedural`	Procedural memories
`knowledge`	Knowledge Vault memories
`experience`	Episodic, Semantic, and Knowledge Vault memories together

Use dry_run: true to fetch counts and inspect what would be processed without applying updates. The optional model field can override the auto-dream agent model for that request. For procedural mode, pass the target meta_agent_id and optionally last_n_sessions to distill recent session experiences.

Python client example:

result = client.auto_dream(
    user_id="demo-user",
    mode="procedural",
    meta_agent_id=meta_agent.id,
    last_n_sessions=3,
    dry_run=False,
)
print(result)

Upgrading an Existing Database

Fresh databases get their full schema automatically at startup. Existing databases require manual migrations when upgrading to a version that alters tables — startup creates missing tables but never adds columns to existing ones. If migrations are pending, the server refuses to start and names the exact scripts to run.

For the skill-based procedural memory release, run against your database (in this order):

psql "$MIRIX_PG_URI" -f scripts/migrate_procedural_to_skill.sql
psql "$MIRIX_PG_URI" -f scripts/migrate_add_message_session_id.sql
psql "$MIRIX_PG_URI" -f scripts/migrate_add_message_session_id_phase2.sql   # outside a transaction (CREATE INDEX CONCURRENTLY)
psql "$MIRIX_PG_URI" -f scripts/migrate_add_conversation_message.sql
psql "$MIRIX_PG_URI" -f scripts/migrate_add_conversation_message_phase2.sql # outside a transaction
psql "$MIRIX_PG_URI" -f scripts/migrate_add_skill_experience.sql
psql "$MIRIX_PG_URI" -f scripts/migrate_add_agent_trigger_state.sql
psql "$MIRIX_PG_URI" -f scripts/migrate_backfill_procedural_scope.sql   # backfill filter_tags['scope'] from each skill's owning client

Each script is idempotent where possible and documents its own preconditions in its header. Run them once, then restart the server.

License

Mirix is released under the Apache License 2.0. See the LICENSE file for more details.

Contact

For questions, suggestions, or issues, please open an issue on the GitHub repository or contact us at founders@mirix.io

Join Our Community

Connect with other Mirix users, share your thoughts, and get support:

💬 Discord Community

Join our Discord server for real-time discussions, support, and community updates: https://discord.gg/S6CeHNrJ

🎯 Weekly Discussion Sessions

We host weekly discussion sessions where you can:

Discuss issues and bugs
Share ideas about future directions
Get general consultations and support
Connect with the development team and community

📅 Schedule: Friday nights, 8-9 PM PST 🔗 Zoom Link: https://ucsd.zoom.us/j/96278791276

📱 WeChat Group

You can add the account ari_asm so that I can add you to the group chat.

Acknowledgement

We would like to thank Letta for open-sourcing their framework, which served as the foundation for the memory system in this project.

TalentDelta provenance record (added at packaging)

Packaged for: TalentDelta catalogue (draft; gated by review)
Upstream: Mirix-AI/MIRIX
Pinned commit: 8cb06a62bbb7c478beb33dd4f2815696a72df482 (2026-08-20)
Licence: Apache-2.0 — Apache License 2.0 at the repository root, shipped byte-identical to the pin. Permissive: use, modification, distribution and commercial use allowed with attribution and licence text. No NOTICE file exists upstream; no per-file headers are added and no shipped file is edited. Attribution to Mirix AI is recorded in the pack README's provenance section and in this upload record.
Upstream author credit: Mirix AI (Mirix-AI)
Runtime: Docker Compose (docker compose up -d) brings up the FastAPI backend on :8531 and the dashboard on :5173; PostgreSQL with pgvector for storage; Python client pip install mirix-client; OpenAI, Anthropic or Google GenAI keys configured per agent; optional voice and screen-capture extras
Changes made at packaging: this section was appended to README.md. No upstream path is excluded. Apart from this provenance section appended to README.md, no file was added, removed, renamed or edited; every upstream file is byte-identical to the pinned commit.
Safety read of the packaged archive (packaging time, 2026-10-24): Static safety read of the shipped archive (496 files): 86 pattern hits, none a live secret. 67 are api-key patterns - attribute assignments in code, environment reads, and empty placeholders in env.example and the eval configs; 2 are 27- and 30-character placeholders in env.example; 14 are addresses, the maintainer's in packaging metadata and docs, support addresses, and invented people in add_test_memory.py; 3 are absolute user paths in upstream docs. The sample production password and Redis URL are invented fixtures. No credential, token or private key ships.

Packaging notes (TalentDelta)

Six memory agents are separate modules under mirix/agent/ (core, episodic, semantic, procedural, resource, knowledge vault), each with its own system prompt under mirix/prompts/, coordinated by a meta agent with reflexion, background and auto-dream consolidation passes.
Privacy is the stated design: long-term data is stored locally in the operator's PostgreSQL, screen observation is a configurable setting, and the pack adds no outbound telemetry of its own.
No keys ship. docker/env.example and the sample clients carry placeholders only; model, embedding and database credentials are set by the operator. Mirix speaks to OpenAI, Anthropic and Google GenAI endpoints that the operator configures.
Screen observation is sensitive by nature: the shipped README documents the privacy controls and per-agent scoping; running it on a shared machine without those settings is the operator's call, not a default of the pack.
Sample fixtures under samples/ contain invented people, companies and a dummy Redis URL used to demonstrate memory extraction.

mirix-personal-memory-agent/assets/icon.pngbinary · 913.0 KB
Binary — download to inspect.
mirix-personal-memory-agent/assets/logo.pngbinary · 483.1 KB
Binary — download to inspect.

mirix-personal-memory-agent/dashboard/Dockerfiletext · 1.0 KB

# ============================================================================
# Mirix Dashboard Dockerfile
# ============================================================================
# Multi-stage build: Node.js for building, Nginx for serving
# ============================================================================

# Stage 1: Build
FROM node:20-alpine as builder

WORKDIR /app

# Copy package files
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci

# Copy source code
COPY . .

# Build the application
RUN npm run build

# Stage 2: Production
FROM nginx:alpine as production

# Copy custom nginx configuration
COPY nginx.conf /etc/nginx/conf.d/default.conf

# Copy built assets from builder stage
COPY --from=builder /app/dist /usr/share/nginx/html

# Expose port
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD wget --quiet --tries=1 --spider http://localhost:80/ || exit 1

# Start nginx
CMD ["nginx", "-g", "daemon off;"]

mirix-personal-memory-agent/dashboard/index.htmlcode · 0.4 KB

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Mirix Dashboard</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

mirix-personal-memory-agent/dashboard/nginx.conftext · 1.3 KB

server {
    listen 80;
    server_name localhost;
    root /usr/share/nginx/html;
    index index.html;

    # Gzip compression
    gzip on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
    gzip_min_length 1000;

    # API proxy - forwards /api requests to the backend
    location /api/ {
        proxy_pass http://mirix_api:8531/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 300s;
        proxy_connect_timeout 75s;
    }

    # Serve static files
    location /assets/ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # SPA fallback - all routes go to index.html
    location / {
        try_files $uri $uri/ /index.html;
    }

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
}

mirix-personal-memory-agent/dashboard/package-lock.jsontext · 177.8 KB
No inline preview for this entry.

mirix-personal-memory-agent/dashboard/package.jsoncode · 1.2 KB

{
  "name": "mirix-dashboard",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
    "preview": "vite preview"
  },
  "dependencies": {
    "@radix-ui/react-dialog": "^1.0.5",
    "@radix-ui/react-popover": "^1.0.7",
    "@radix-ui/react-slot": "^1.0.2",
    "axios": "^1.6.7",
    "class-variance-authority": "^0.7.0",
    "clsx": "^2.1.0",
    "framer-motion": "^11.0.3",
    "lucide-react": "^0.330.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.22.0",
    "tailwind-merge": "^2.2.1"
  },
  "devDependencies": {
    "@types/node": "^20.11.0",
    "@types/react": "^18.2.56",
    "@types/react-dom": "^18.2.19",
    "@typescript-eslint/eslint-plugin": "^7.0.2",
    "@typescript-eslint/parser": "^7.0.2",
    "@vitejs/plugin-react": "^4.2.1",
    "autoprefixer": "^10.4.17",
    "eslint": "^8.56.0",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-react-refresh": "^0.4.5",
    "postcss": "^8.4.35",
    "tailwindcss": "^3.4.1",
    "typescript": "^5.2.2",
    "vite": "^5.1.4"
  }
}

mirix-personal-memory-agent/dashboard/postcss.config.jscode · 0.1 KB

export default {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
}

mirix-personal-memory-agent/dashboard/src/App.tsxcode · 0.8 KB

import { BrowserRouter as Router, Routes, Route, Navigate } from 'react-router-dom'
import { AuthProvider } from '@/contexts/AuthContext'
import { Login } from '@/pages/Login'
import { Register } from '@/pages/Register'
import { Dashboard } from '@/pages/Dashboard'
import { ProtectedRoute } from '@/components/ProtectedRoute'

function App() {
  return (
    <Router>
      <AuthProvider>
        <Routes>
          <Route path="/login" element={<Login />} />
          <Route path="/register" element={<Register />} />
          <Route path="/dashboard/*" element={
            <ProtectedRoute>
              <Dashboard />
            </ProtectedRoute>
          } />
          <Route path="/" element={<Navigate to="/dashboard" replace />} />
        </Routes>
      </AuthProvider>
    </Router>
  )
}

export default App

mirix-personal-memory-agent/dashboard/src/api/client.tscode · 0.8 KB

import axios from 'axios';

const apiClient = axios.create({
  baseURL: '/api',
  headers: {
    'Content-Type': 'application/json',
  },
});

apiClient.interceptors.request.use((config) => {
  const token = localStorage.getItem('token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

apiClient.interceptors.response.use(
  (response) => response,
  (error) => {
    const requestUrl = error.response?.config?.url;
    const isAuthPath = requestUrl === '/admin/auth/login' || requestUrl === '/admin/auth/register';

    if (error.response?.status === 401 && !isAuthPath) {
      localStorage.removeItem('token');
      window.location.href = '/login';
    }
    return Promise.reject(error);
  }
);

export default apiClient;

mirix-personal-memory-agent/dashboard/src/assets/.gitkeeptext · 0.1 KB

# Assets Directory
This directory contains static assets like images.

mirix-personal-memory-agent/dashboard/src/assets/logo.pngbinary · 483.1 KB
Binary — download to inspect.

mirix-personal-memory-agent/dashboard/src/components/ProtectedRoute.tsxcode · 0.5 KB

import React from 'react';
import { Navigate } from 'react-router-dom';
import { useAuth } from '@/contexts/AuthContext';

export const ProtectedRoute: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const { isAuthenticated, isLoading } = useAuth();

  if (isLoading) {
    return <div className="flex h-screen items-center justify-center bg-background text-white">Loading...</div>;
  }

  if (!isAuthenticated) {
    return <Navigate to="/login" replace />;
  }

  return <>{children}</>;
};

mirix-personal-memory-agent/dashboard/src/components/UserSwitcher.tsxcode · 7.6 KB

import React, { useState } from 'react';
import { ChevronsUpDown, Check, Plus, User as UserIcon, Trash2 } from 'lucide-react';
import { useWorkspace, User } from '@/contexts/WorkspaceContext';
import { useAuth } from '@/contexts/AuthContext';
import { cn } from '@/lib/utils';
import { Button } from '@/components/ui/button';
import {
  Popover,
  PopoverContent,
  PopoverTrigger,
} from '@/components/ui/popover';
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
  DialogTrigger,
} from "@/components/ui/dialog"
import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';

export const UserSwitcher: React.FC<{ className?: string }> = ({ className }) => {
  const { users, selectedUser, setSelectedUser, createUser, deleteUser, isLoading } = useWorkspace();
  const { user: clientUser } = useAuth();
  const [open, setOpen] = useState(false);
  const [dialogOpen, setDialogOpen] = useState(false);
  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
  const [userToDelete, setUserToDelete] = useState<User | null>(null);
  const [newUserName, setNewUserName] = useState('');
  const [loading, setLoading] = useState(false);
  const [deleteLoading, setDeleteLoading] = useState(false);

  // Check if a user is the default user
  const isDefaultUser = (user: User) => {
    return clientUser?.default_user_id === user.id;
  };

  const handleCreateUser = async (e: React.FormEvent) => {
    e.preventDefault();
    setLoading(true);
    try {
      await createUser(newUserName);
      setNewUserName('');
      setDialogOpen(false);
      setOpen(false);
    } catch (error) {
      console.error("Failed to create user", error);
    } finally {
      setLoading(false);
    }
  };

  const handleDeleteClick = (e: React.MouseEvent, user: User) => {
    e.stopPropagation();
    setUserToDelete(user);
    setDeleteDialogOpen(true);
  };

  const handleConfirmDelete = async () => {
    if (!userToDelete) return;
    setDeleteLoading(true);
    try {
      await deleteUser(userToDelete.id);
      setDeleteDialogOpen(false);
      setUserToDelete(null);
      setOpen(false);
    } catch (error) {
      console.error("Failed to delete user", error);
    } finally {
      setDeleteLoading(false);
    }
  };

  // Get display name - just show the user name as-is
  const getDisplayName = (user: User) => {
    return user.name;
  };

  return (
    <Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
      <Popover open={open} onOpenChange={setOpen}>
        <PopoverTrigger asChild>
          <Button
            variant="outline"
            role="combobox"
            aria-expanded={open}
            className={cn("w-full justify-between", className)}
            disabled={isLoading}
          >
            <div className="flex items-center gap-2 truncate">
              <div className="h-5 w-5 rounded-full bg-primary/10 flex items-center justify-center text-primary text-xs font-bold">
                {selectedUser?.name.charAt(0).toUpperCase() || 'U'}
              </div>
              <span className="truncate">
                {isLoading ? 'Loading...' : (selectedUser ? getDisplayName(selectedUser) : 'Select User')}
              </span>
            </div>
            <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
          </Button>
        </PopoverTrigger>
        <PopoverContent className="w-[220px] p-0" align="start">
          <div className="max-h-[300px] overflow-y-auto p-1">
            <div className="px-2 py-1.5 text-xs font-semibold text-muted-foreground">
              Users
            </div>
            {users.map((user) => (
              <div
                key={user.id}
                className={cn(
                  "group relative flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none hover:bg-accent hover:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
                  selectedUser?.id === user.id && "bg-accent text-accent-foreground"
                )}
                onClick={() => {
                  setSelectedUser(user);
                  setOpen(false);
                }}
              >
                <UserIcon className="mr-2 h-4 w-4 shrink-0" />
                <span className="truncate flex-1">{user.name}</span>
                {selectedUser?.id === user.id && (
                  <Check className="ml-2 h-4 w-4 shrink-0" />
                )}
                {!isDefaultUser(user) && (
                  <button
                    className="ml-2 h-6 w-6 rounded opacity-0 group-hover:opacity-100 hover:bg-destructive/20 flex items-center justify-center transition-opacity"
                    onClick={(e) => handleDeleteClick(e, user)}
                    title="Delete user"
                  >
                    <Trash2 className="h-3.5 w-3.5 text-destructive" />
                  </button>
                )}
              </div>
            ))}
            <div className="border-t my-1" />
            <DialogTrigger asChild>
              <div
                className="relative flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none hover:bg-accent hover:text-accent-foreground"
              >
                <Plus className="mr-2 h-4 w-4" />
                Create New User
              </div>
            </DialogTrigger>
          </div>
        </PopoverContent>
      </Popover>

      <DialogContent className="sm:max-w-[425px]">
        <DialogHeader>
          <DialogTitle>Create User</DialogTitle>
          <DialogDescription>
            Create a new user to associate memories and interactions with.
          </DialogDescription>
        </DialogHeader>
        <form onSubmit={handleCreateUser}>
          <div className="grid gap-4 py-4">
            <div className="grid grid-cols-4 items-center gap-4">
              <Label htmlFor="name" className="text-right">
                Name
              </Label>
              <Input
                id="name"
                value={newUserName}
                onChange={(e) => setNewUserName(e.target.value)}
                className="col-span-3"
                placeholder="e.g. John Doe"
                required
              />
            </div>
          </div>
          <DialogFooter>
            <Button type="submit" disabled={loading}>
              {loading ? 'Creating...' : 'Create User'}
            </Button>
          </DialogFooter>
        </form>
      </DialogContent>

      {/* Delete Confirmation Dialog */}
      <Dialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>
        <DialogContent className="sm:max-w-[425px]">
          <DialogHeader>
            <DialogTitle>Delete User</DialogTitle>
            <DialogDescription>
              Are you sure you want to delete <strong>{userToDelete?.name}</strong>? This will soft-delete the user and all associated memories. This action cannot be undone.
            </DialogDescription>
          </DialogHeader>
          <DialogFooter className="gap-2 sm:gap-0">
            <Button
              type="button"
              variant="outline"
              onClick={() => setDeleteDialogOpen(false)}
              disabled={deleteLoading}
            >
              Cancel
            </Button>
            <Button
              type="button"
              variant="destructive"
              onClick={handleConfirmDelete}
              disabled={deleteLoading}
            >
              {deleteLoading ? 'Deleting...' : 'Delete User'}
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
    </Dialog>
  );
};

mirix-personal-memory-agent/dashboard/src/components/ui/button.tsxcode · 1.8 KB

import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"

const buttonVariants = cva(
  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
  {
    variants: {
      variant: {
        default: "bg-primary text-primary-foreground hover:bg-primary/90",
        destructive:
          "bg-destructive text-destructive-foreground hover:bg-destructive/90",
        outline:
          "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
        secondary:
          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
        ghost: "hover:bg-accent hover:text-accent-foreground",
        link: "text-primary underline-offset-4 hover:underline",
      },
      size: {
        default: "h-10 px-4 py-2",
        sm: "h-9 rounded-md px-3",
        lg: "h-11 rounded-md px-8",
        icon: "h-10 w-10",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

export interface ButtonProps
  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
    VariantProps<typeof buttonVariants> {
  asChild?: boolean
}

const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
  ({ className, variant, size, asChild = false, ...props }, ref) => {
    const Comp = asChild ? Slot : "button"
    return (
      <Comp
        className={cn(buttonVariants({ variant, size, className }))}
        ref={ref}
        {...props}
      />
    )
  }
)
Button.displayName = "Button"

export { Button, buttonVariants }

mirix-personal-memory-agent/dashboard/src/components/ui/card.tsxcode · 1.8 KB

import * as React from "react"
import { cn } from "@/lib/utils"

const Card = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn(
      "rounded-lg border bg-card text-card-foreground shadow-sm",
      className
    )}
    {...props}
  />
))
Card.displayName = "Card"

const CardHeader = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn("flex flex-col space-y-1.5 p-6", className)}
    {...props}
  />
))
CardHeader.displayName = "CardHeader"

const CardTitle = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes<HTMLHeadingElement>
>(({ className, ...props }, ref) => (
  <h3
    ref={ref}
    className={cn(
      "text-2xl font-semibold leading-none tracking-tight",
      className
    )}
    {...props}
  />
))
CardTitle.displayName = "CardTitle"

const CardDescription = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes<HTMLParagraphElement>
>(({ className, ...props }, ref) => (
  <p
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
CardDescription.displayName = "CardDescription"

const CardContent = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
))
CardContent.displayName = "CardContent"

const CardFooter = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn("flex items-center p-6 pt-0", className)}
    {...props}
  />
))
CardFooter.displayName = "CardFooter"

export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }

mirix-personal-memory-agent/dashboard/src/components/ui/dialog.tsxcode · 3.7 KB

import * as React from "react"
import * as DialogPrimitive from "@radix-ui/react-dialog"
import { X } from "lucide-react"
import { cn } from "@/lib/utils"

const Dialog = DialogPrimitive.Root

const DialogTrigger = DialogPrimitive.Trigger

const DialogPortal = DialogPrimitive.Portal

const DialogClose = DialogPrimitive.Close

const DialogOverlay = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Overlay>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Overlay
    ref={ref}
    className={cn(
      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
      className
    )}
    {...props}
  />
))
DialogOverlay.displayName = DialogPrimitive.Overlay.displayName

const DialogContent = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
>(({ className, children, ...props }, ref) => (
  <DialogPortal>
    <DialogOverlay />
    <DialogPrimitive.Content
      ref={ref}
      className={cn(
        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
        className
      )}
      {...props}
    >
      {children}
      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
        <X className="h-4 w-4" />
        <span className="sr-only">Close</span>
      </DialogPrimitive.Close>
    </DialogPrimitive.Content>
  </DialogPortal>
))
DialogContent.displayName = DialogPrimitive.Content.displayName

const DialogHeader = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col space-y-1.5 text-center sm:text-left",
      className
    )}
    {...props}
  />
)
DialogHeader.displayName = "DialogHeader"

const DialogFooter = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
      className
    )}
    {...props}
  />
)
DialogFooter.displayName = "DialogFooter"

const DialogTitle = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Title>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Title
    ref={ref}
    className={cn(
      "text-lg font-semibold leading-none tracking-tight",
      className
    )}
    {...props}
  />
))
DialogTitle.displayName = DialogPrimitive.Title.displayName

const DialogDescription = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Description>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Description
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
DialogDescription.displayName = DialogPrimitive.Description.displayName

export {
  Dialog,
  DialogPortal,
  DialogOverlay,
  DialogClose,
  DialogTrigger,
  DialogContent,
  DialogHeader,
  DialogFooter,
  DialogTitle,
  DialogDescription,
}

mirix-personal-memory-agent/dashboard/src/components/ui/input.tsxcode · 0.8 KB

import * as React from "react"
import { cn } from "@/lib/utils"

export interface InputProps
  extends React.InputHTMLAttributes<HTMLInputElement> {}

const Input = React.forwardRef<HTMLInputElement, InputProps>(
  ({ className, type, ...props }, ref) => {
    return (
      <input
        type={type}
        className={cn(
          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
          className
        )}
        ref={ref}
        {...props}
      />
    )
  }
)
Input.displayName = "Input"

export { Input }

mirix-personal-memory-agent/dashboard/src/components/ui/label.tsxcode · 0.4 KB

import * as React from "react"
import { cn } from "@/lib/utils"

const Label = React.forwardRef<
  HTMLLabelElement,
  React.LabelHTMLAttributes<HTMLLabelElement>
>(({ className, ...props }, ref) => (
  <label
    ref={ref}
    className={cn(
      "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
      className
    )}
    {...props}
  />
))
Label.displayName = "Label"

export { Label }

mirix-personal-memory-agent/dashboard/src/components/ui/popover.tsxcode · 1.2 KB

import * as React from "react"
import * as PopoverPrimitive from "@radix-ui/react-popover"
import { cn } from "@/lib/utils"

const Popover = PopoverPrimitive.Root

const PopoverTrigger = PopoverPrimitive.Trigger

const PopoverContent = React.forwardRef<
  React.ElementRef<typeof PopoverPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
  <PopoverPrimitive.Portal>
    <PopoverPrimitive.Content
      ref={ref}
      align={align}
      sideOffset={sideOffset}
      className={cn(
        "z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
        className
      )}
      {...props}
    />
  </PopoverPrimitive.Portal>
))
PopoverContent.displayName = PopoverPrimitive.Content.displayName

export { Popover, PopoverTrigger, PopoverContent }

mirix-personal-memory-agent/dashboard/src/components/ui/textarea.tsxcode · 0.8 KB

import * as React from "react"
import { cn } from "@/lib/utils"

export interface TextareaProps
  extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}

const Textarea = React.forwardRef<HTMLTextAreaElement, TextareaProps>(
  ({ className, ...props }, ref) => {
    return (
      <textarea
        className={cn(
          "flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
          className
        )}
        ref={ref}
        {...props}
      />
    )
  }
)
Textarea.displayName = "Textarea"

export { Textarea }

mirix-personal-memory-agent/dashboard/src/contexts/AuthContext.tsxcode · 2.0 KB

import { createContext, useContext, useState, useEffect } from 'react';
import apiClient from '@/api/client';
import { useNavigate } from 'react-router-dom';

interface ClientUser {
  id: string;
  name: string;
  email: string;
  scope: string;
  status: string;
  default_user_id: string;  // Default user for memory operations
  created_at: string;
}

interface AuthContextType {
  user: ClientUser | null;
  token: string | null;
  login: (token: string, user: ClientUser) => void;
  logout: () => void;
  isAuthenticated: boolean;
  isLoading: boolean;
}

const AuthContext = createContext<AuthContextType | null>(null);

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [user, setUser] = useState<ClientUser | null>(null);
  const [token, setToken] = useState<string | null>(localStorage.getItem('token'));
  const [isLoading, setIsLoading] = useState(true);
  const navigate = useNavigate();

  useEffect(() => {
    const initAuth = async () => {
      const storedToken = localStorage.getItem('token');
      if (storedToken) {
        try {
          const response = await apiClient.get('/admin/auth/me');
          setUser(response.data);
          setToken(storedToken);
        } catch (error) {
          console.error('Failed to fetch user profile', error);
          logout();
        }
      }
      setIsLoading(false);
    };

    initAuth();
  }, []);

  const login = (newToken: string, newUser: ClientUser) => {
    localStorage.setItem('token', newToken);
    setToken(newToken);
    setUser(newUser);
    navigate('/dashboard');
  };

  const logout = () => {
    localStorage.removeItem('token');
    setToken(null);
    setUser(null);
    navigate('/login');
  };

  return (
    <AuthContext.Provider value={{ user, token, login, logout, isAuthenticated: !!user, isLoading }}>
      {children}
    </AuthContext.Provider>
  );
};

mirix-personal-memory-agent/dashboard/src/contexts/WorkspaceContext.tsxcode · 3.5 KB

import React, { createContext, useContext, useState, useEffect } from 'react';
import apiClient from '@/api/client';
import { useAuth } from '@/contexts/AuthContext';

export interface User {
  id: string;
  name: string;
  organization_id: string;
  status: string;
  timezone: string;
  created_at: string;
}

interface WorkspaceContextType {
  users: User[];
  selectedUser: User | null;
  setSelectedUser: (user: User) => void;
  refreshUsers: () => Promise<void>;
  createUser: (name: string) => Promise<User>;
  deleteUser: (userId: string) => Promise<void>;
  isLoading: boolean;
}

const WorkspaceContext = createContext<WorkspaceContextType | null>(null);

export const useWorkspace = () => {
  const context = useContext(WorkspaceContext);
  if (!context) {
    throw new Error('useWorkspace must be used within a WorkspaceProvider');
  }
  return context;
};

export const WorkspaceProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const { user: clientUser } = useAuth(); // This is the Client (Admin) - includes default_user_id
  const [users, setUsers] = useState<User[]>([]);
  const [selectedUser, setSelectedUser] = useState<User | null>(null);
  const [isLoading, setIsLoading] = useState(true);

  const fetchUsers = async () => {
    if (!clientUser) return;
    setIsLoading(true);
    try {
      // The clientUser now includes default_user_id from the backend
      const defaultUserId = clientUser.default_user_id;
      
      // List all users
      const response = await apiClient.get('/users');
      const userList = response.data;
      setUsers(userList);
      
      // Auto-select the default user if none is selected yet
      if (!selectedUser && userList.length > 0) {
        // Find the default user by ID
        const defaultUser = userList.find((u: User) => u.id === defaultUserId);
        if (defaultUser) {
          setSelectedUser(defaultUser);
        } else {
          // Fallback to first user if default not found
          setSelectedUser(userList[0]);
        }
      }
    } catch (error) {
      console.error("Failed to fetch users", error);
    } finally {
      setIsLoading(false);
    }
  };

  const createUser = async (name: string) => {
    if (!clientUser) throw new Error("Not authenticated");
    
    const response = await apiClient.post('/users/create_or_get', {
      name: name,
    });
    
    const newUser = response.data;
    await fetchUsers(); // Refresh list
    setSelectedUser(newUser); // Switch to new user
    return newUser;
  };

  const deleteUser = async (userId: string) => {
    if (!clientUser) throw new Error("Not authenticated");
    
    await apiClient.delete(`/users/${userId}`);
    
    // If deleted user was selected, switch to another user
    if (selectedUser?.id === userId) {
      const remainingUsers = users.filter(u => u.id !== userId);
      if (remainingUsers.length > 0) {
        // Try to select the default user, otherwise first available
        const defaultUser = remainingUsers.find(u => u.id === clientUser.default_user_id);
        setSelectedUser(defaultUser || remainingUsers[0]);
      } else {
        setSelectedUser(null);
      }
    }
    
    await fetchUsers(); // Refresh list
  };

  useEffect(() => {
    if (clientUser) {
      fetchUsers();
    }
  }, [clientUser]);

  return (
    <WorkspaceContext.Provider value={{ 
      users, 
      selectedUser, 
      setSelectedUser, 
      refreshUsers: fetchUsers,
      createUser,
      deleteUser,
      isLoading 
    }}>
      {children}
    </WorkspaceContext.Provider>
  );
};

mirix-personal-memory-agent/dashboard/src/index.csscode · 0.8 KB

@tailwind base;
@tailwind components;
@tailwind utilities;

@layer base {
  :root {
    --background: 0 0% 3.9%;
    --foreground: 0 0% 98%;
    --card: 0 0% 3.9%;
    --card-foreground: 0 0% 98%;
    --popover: 0 0% 3.9%;
    --popover-foreground: 0 0% 98%;
    --primary: 0 0% 98%;
    --primary-foreground: 0 0% 9%;
    --secondary: 0 0% 14.9%;
    --secondary-foreground: 0 0% 98%;
    --muted: 0 0% 14.9%;
    --muted-foreground: 0 0% 63.9%;
    --accent: 0 0% 14.9%;
    --accent-foreground: 0 0% 98%;
    --destructive: 0 62.8% 30.6%;
    --destructive-foreground: 0 0% 98%;
    --border: 0 0% 14.9%;
    --input: 0 0% 14.9%;
    --ring: 0 0% 83.1%;
  }
}

@layer base {
  * {
    @apply border-border;
  }
  body {
    @apply bg-background text-foreground;
    font-feature-settings: "rlig" 1, "calt" 1;
  }
}

mirix-personal-memory-agent/dashboard/src/lib/utils.tscode · 0.2 KB

import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

mirix-personal-memory-agent/dashboard/src/main.tsxcode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/Dashboard.tsxcode · 3.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/Login.tsxcode · 4.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/Register.tsxcode · 4.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/dashboard/ApiKeys.tsxcode · 11.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/dashboard/Memories.tsxcode · 32.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/pages/dashboard/Overview.tsxcode · 3.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/src/vite-env.d.tscode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/tailwind.config.jscode · 1.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/tsconfig.jsoncode · 0.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/tsconfig.node.jsoncode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/dashboard/vite.config.tscode · 0.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/docker-compose.test.ymlcode · 4.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/docker-compose.ymlcode · 8.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/docker/README.mdmarkdown · 3.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/docker/env.exampletext · 2.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/docs/ARCHITECTURE.mdmarkdown · 10.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/docs/FORMATTING_SETUP.mdmarkdown · 4.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/docs/Mirix_async_native_changes.mdmarkdown · 10.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/docs/architecture.htmltext · 89.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/eval_token_usage.pycode · 4.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/README.mdmarkdown · 0.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/_chunking.pycode · 3.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/clear_records.pycode · 6.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/configs/0201c.yamlcode · 1.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/configs/mab.yamlcode · 1.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/configs/openrouter_template.yamlcode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/llm_judge.pycode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/__init__.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/_eval_db.pycode · 6.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/llm_judge_mab.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/llm_judge_mab_summary.pycode · 17.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/llm_judge_substring.pycode · 2.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/longmem_eval.pycode · 17.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/lru_eval.pycode · 16.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/ruler_eval.pycode · 15.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/run_mab_longmem_eval.shcode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/run_mab_lru_eval.shcode · 5.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mab/run_mab_ruler_eval.shcode · 5.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/main_eval.pycode · 12.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/mirix_memory_system.pycode · 6.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/organize_results.pycode · 22.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0130a/episodic_memory_agent.txtcode · 5.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0130a/meta_memory_agent.txtcode · 1.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0130a/semantic_memory_agent.txtcode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0131b/episodic_memory_agent.txtcode · 6.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0131b/meta_memory_agent.txtcode · 2.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0131b/semantic_memory_agent.txtcode · 7.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0201a/episodic_memory_agent.txtcode · 8.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0201a/meta_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0201a/semantic_memory_agent.txtcode · 9.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207c/core_memory_agent.txtcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207c/episodic_memory_agent.txtcode · 5.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207c/meta_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207c/semantic_memory_agent.txtcode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207d/core_memory_agent.txtcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207d/episodic_memory_agent.txtcode · 5.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207d/meta_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0207d/semantic_memory_agent.txtcode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208a/episodic_memory_agent.txtcode · 15.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208a/meta_memory_agent.txtcode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208a/semantic_memory_agent.txtcode · 20.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208b/episodic_memory_agent.txtcode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208b/meta_memory_agent.txtcode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/prompts/0208b/semantic_memory_agent.txtcode · 7.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/evals/task_agent.pycode · 18.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/init.sqlcode · 1.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/main.spectext · 1.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/__init__.pycode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/__main__.pycode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/__init__.pycode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/agent.pytext · 142.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/agent_configs.pycode · 2.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/agent_states.pycode · 1.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/app_constants.pycode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/app_utils.pycode · 0.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/auto_dream_agent.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/background_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/core_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/episodic_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/knowledge_vault_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/message_queue.pycode · 4.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/meta_agent.pycode · 21.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/meta_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/procedural_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/reflexion_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/resource_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/semantic_memory_agent.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/temporary_message_accumulator.pycode · 39.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/tool_validators.pycode · 12.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/agent/upload_manager.pycode · 9.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/client/__init__.pycode · 0.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/client/client.pycode · 12.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/client/remote_client.pytext · 79.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/client/utils.pycode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/config.pycode · 12.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/examples/mirix_azure.yamlcode · 1.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/examples/mirix_claude.yamlcode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/examples/mirix_gemini.yamlcode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/examples/mirix_openai.yamlcode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/examples/mirix_openai_with_auto_dram.yamlcode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix.yamlcode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_azure_example.yamlcode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_custom_model.yamlcode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_custom_prompts.yamlcode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_gemini.yamlcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_gpt4.yamlcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_gpt4o-mini.yamlcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/legacy_configs/mirix_monitor.yamlcode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/configs/mirix.yamlcode · 5.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/constants.pycode · 17.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/__init__.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/cache_provider.pycode · 3.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/filter_tags_query.pycode · 10.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/pglite_connector.pycode · 2.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/redis_cache_provider.pycode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/redis_client.pytext · 70.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/database/schema_extractor.pycode · 10.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/embeddings.pycode · 20.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/errors.pycode · 7.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/ast_parsers.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/function_sets/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/function_sets/base.pycode · 15.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/function_sets/extras.pycode · 9.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/function_sets/memory_tools.pytext · 80.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/functions.pycode · 7.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/helpers.pycode · 12.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/__init__.pycode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/base_client.pycode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/exceptions.pycode · 1.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/gmail_client.pycode · 19.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/manager.pycode · 12.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/stdio_client.pycode · 4.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/mcp_client/types.pycode · 6.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/functions/schema_generator.pycode · 18.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/__init__.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/converters.pycode · 13.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/datetime_helpers.pycode · 2.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/json_helpers.pycode · 1.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/json_parsing.pycode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/keyed_locks.pycode · 1.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/message_helpers.pycode · 2.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/helpers/tool_rule_solver.pycode · 6.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/interface.pycode · 20.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/jobs/__init__.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/jobs/cleanup_raw_memories.pycode · 3.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/anthropic.pycode · 17.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/anthropic_client.pycode · 27.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/auth_provider.pycode · 4.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/aws_bedrock.pycode · 3.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/azure_openai.pycode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/azure_openai_client.pycode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/azure_openai_constants.pycode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/cohere.pycode · 13.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/cohere_client.pycode · 1.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/google_ai.pycode · 20.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/google_ai_client.pycode · 23.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/helpers.pycode · 12.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/llm_api_tools.pycode · 23.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/llm_client.pycode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/llm_client_base.pycode · 11.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/mistral.pycode · 1.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/openai.pycode · 22.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/llm_api/openai_client.pycode · 18.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/local_client/__init__.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/local_client/local_client.pytext · 77.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/log.pycode · 5.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/memory.pycode · 4.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/observability/__init__.pycode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/observability/context.pycode · 2.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/observability/langfuse_client.pycode · 6.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/observability/trace_propagation.pycode · 4.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/__all__.pycode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/__init__.pycode · 1.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/agent.pycode · 4.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/agent_trigger_state.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/base.pycode · 3.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/block.pycode · 5.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/client.pycode · 1.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/client_api_key.pycode · 1.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/cloud_file_mapping.pycode · 1.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/conversation_message.pycode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/custom_columns.pycode · 5.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/enums.pycode · 0.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/episodic_memory.pycode · 8.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/errors.pycode · 0.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/file.pycode · 2.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/knowledge_vault.pycode · 6.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/message.pycode · 5.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/mixins.pycode · 1.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/organization.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/procedural_memory.pycode · 7.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/provider.pycode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/raw_memory.pycode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/resource_memory.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/semantic_memory.pycode · 7.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/skill_experience.pycode · 5.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/sqlalchemy_base.pycode · 36.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/sqlite_functions.pycode · 7.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/step.pycode · 2.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/tool.pycode · 2.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/tools_agents.pycode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/orm/user.pycode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/gpt_persona.pycode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/gpt_summarize.pycode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/gpt_system.pycode · 0.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/chill_buddy.txtcode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/concise_analyst.txtcode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/friendly_conversationalist.txtcode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/helpful_assistant.txtcode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/playful_Ironist.txtcode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/personas/project_manager.txtcode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/core.txtcode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/episodic.txtcode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/experience.txtcode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/knowledge.txtcode · 0.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/procedural.txtcode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/resource.txtcode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/auto_dream_agent/semantic.txtcode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/background_agent.txtcode · 7.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/chat_agent.txtcode · 5.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/core_memory_agent.txtcode · 5.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/episodic_memory_agent.txtcode · 5.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/knowledge_vault_memory_agent.txtcode · 4.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/meta_memory_agent.txtcode · 9.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/procedural_memory_agent.txtcode · 6.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/reflexion_agent.txtcode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/resource_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/base/semantic_memory_agent.txtcode · 5.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/auto_dream_agent.txtcode · 7.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/background_agent.txtcode · 8.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/chat_agent.txtcode · 2.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/chat_agent_monitor_on.txtcode · 2.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/core_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/episodic_memory_agent.txtcode · 5.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/knowledge_vault_memory_agent.txtcode · 4.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/meta_memory_agent.txtcode · 9.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/procedural_memory_agent.txtcode · 3.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/reflexion_agent.txtcode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/resource_memory_agent.txtcode · 4.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/prompts/system/screen_monitor/semantic_memory_agent.txtcode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/__init__.pycode · 3.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/config.pycode · 2.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/kafka_queue.pycode · 7.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/manager.pycode · 8.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/memory_queue.pycode · 6.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/message.prototext · 3.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/message_pb2.pycode · 5.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/message_pb2.pyitext · 6.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/message_pb2_grpc.pycode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/queue_interface.pycode · 1.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/queue_util.pycode · 6.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/queue/worker.pycode · 14.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/agent.pycode · 15.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/agent_trigger_state.pycode · 3.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/auto_dream.pycode · 2.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/block.pycode · 5.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/client.pycode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/client_api_key.pycode · 3.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/cloud_file_mapping.pycode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/conversation_message.pycode · 4.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/embedding_config.pycode · 4.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/enums.pycode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/environment_variables.pycode · 2.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/episodic_memory.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/file.pycode · 1.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/health.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/knowledge_vault.pycode · 5.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/llm_config.pycode · 7.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/memory.pycode · 10.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/message.pycode · 54.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/mirix_base.pycode · 3.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/mirix_message.pycode · 14.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/mirix_message_content.pycode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/mirix_request.pycode · 1.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/mirix_response.pycode · 7.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/chat_completion_request.pycode · 3.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/chat_completion_response.pycode · 4.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/chat_completions.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/embedding_response.pycode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/openai/openai.pycode · 7.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/organization.pycode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/procedural_memory.pycode · 10.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/providers.pycode · 29.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/raw_memory.pycode · 9.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/resource_memory.pycode · 4.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/sandbox_config.pycode · 4.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/semantic_memory.pycode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/skill_experience.pycode · 5.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/source.pycode · 2.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/step.pycode · 1.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/tool.pycode · 12.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/tool_rule.pycode · 6.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/usage.pycode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/schemas/user.pycode · 2.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/sdk.pycode · 36.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/security/__init__.pycode · 0.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/security/api_keys.pycode · 0.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/__init__.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/constants.pycode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/rest_api.pytext · 220.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/server.pytext · 64.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/startup.shcode · 1.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/server/utils.pycode · 1.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/admin_user_manager.pycode · 18.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/agent_manager.pytext · 80.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/agent_trigger_state_manager.pycode · 17.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/auto_dream_manager.pycode · 36.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/block_manager.pycode · 22.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/client_manager.pycode · 28.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/cloud_file_mapping_manager.pycode · 6.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/conversation_message_manager.pycode · 18.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/episodic_memory_manager.pytext · 69.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/file_manager.pycode · 8.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/helpers/__init__.pycode · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/helpers/agent_manager_helper.pycode · 10.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/knowledge_vault_manager.pycode · 55.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/mcp_marketplace.pycode · 4.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/mcp_tool_registry.pycode · 11.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/message_manager.pycode · 29.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/organization_manager.pycode · 5.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/per_agent_lock_manager.pycode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/procedural_evolution_runtime.pycode · 2.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/procedural_memory_manager.pytext · 77.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/provider_manager.pycode · 5.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/raw_memory_manager.pycode · 28.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/resource_memory_manager.pycode · 51.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/semantic_memory_manager.pycode · 59.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/session_experience_distiller.pycode · 25.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/skill_experience_curator.pycode · 19.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/skill_experience_manager.pycode · 12.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/step_manager.pycode · 1.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/tool_execution_sandbox.pycode · 25.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/tool_manager.pycode · 7.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/user_manager.pycode · 22.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/services/utils.pycode · 6.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/settings.pycode · 11.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/system.pycode · 8.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/temporal/__init__.pycode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/temporal/temporal_parser.pycode · 5.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/tracing.pycode · 8.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/utils.pycode · 61.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/mirix/voice_utils.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/package-lock.jsoncode · 0.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/poetry.locktext · 633.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/pyproject.tomlcode · 5.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/pyrightconfig.jsoncode · 1.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/pytest.initext · 1.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/requirements.txtcode · 0.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/run_client.pycode · 19.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/run_client_auto_dream.pycode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/README.mdmarkdown · 0.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/add_test_memory.pycode · 14.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/claude_agent.pycode · 7.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/claude_agent_original.pycode · 2.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/custom_auth_example.pycode · 4.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/generate_demo_api_key.pycode · 1.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/langgraph_integration.pycode · 7.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/langgraph_integration_azure.pycode · 2.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/load_json_batch_conversations.pycode · 13.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/load_test_add_memory.pycode · 15.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/load_test_messages.txttext · 1453.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/mirix_memory_viewer.pycode · 5.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/new_client_example.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/poetry.locktext · 629.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/pyproject.tomlcode · 4.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/samples/run_client.pycode · 18.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/CLEAN_CACHE_README.mdmarkdown · 3.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/clean_cache.pycode · 7.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/clean_cache.shcode · 7.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_agent_trigger_state.sqlcode · 2.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_conversation_message.sqlcode · 3.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_conversation_message_phase2.sqlcode · 1.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_conversation_message_session_tag.sqlcode · 1.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_message_session_id.sqlcode · 2.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_message_session_id_phase2.sqlcode · 0.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_add_skill_experience.sqlcode · 2.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_backfill_procedural_scope.sqlcode · 3.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/migrate_procedural_to_skill.sqlcode · 5.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/README.mdmarkdown · 9.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/README_CLIENT.mdmarkdown · 1.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/build_packages.shcode · 6.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/requirements_client.txtcode · 0.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/setup_client.pycode · 4.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/packaging/setup_server.pycode · 7.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/reset_database.pycode · 13.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/run_tests_with_docker.shcode · 7.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/start_server.pycode · 3.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/scripts/uninstall_mirix.shcode · 1.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/setup.pycode · 3.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/README.mdmarkdown · 2.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/README_OLLAMA_SETUP.mdmarkdown · 2.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/README_REDIS_TESTS.mdmarkdown · 10.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/conftest.pycode · 2.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_agent_prompt_update.pycode · 20.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_agent_trigger_state.pycode · 17.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_agent_trigger_state_integration.pycode · 26.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_auth_provider.pycode · 9.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_auto_dream_response_changes.pycode · 5.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_block_filter_tag_updates.pycode · 19.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_block_filter_tags_update_mode.pycode · 23.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_cache_provider.pycode · 2.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_client_agent_isolation.pycode · 21.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_conversation_message_manager.pycode · 37.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_conversation_turn_extraction.pycode · 12.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_deletion_apis.pycode · 23.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_experience_to_skill_evolution.pycode · 19.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_filter_function_args.pycode · 6.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_filter_tags_db.pycode · 16.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_filter_tags_query.pycode · 12.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_keyed_locks.pycode · 3.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_langfuse_integration.pycode · 6.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_local_client.pycode · 27.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_memory_api_surface.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_memory_integration.pycode · 8.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_memory_server.pycode · 29.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_message_handling.pycode · 8.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_message_retention.pycode · 13.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_multi_scope_access.pycode · 28.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_procedural_hybrid_search.pycode · 7.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_queue.pycode · 32.0 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_raw_memory.pytext · 89.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_raw_memory_with_real_embeddings.pycode · 7.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_redis_cache_provider.pycode · 3.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_redis_index_upgrade.pycode · 4.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_redis_integration.pycode · 57.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_remote_client_block_filter_tags.pycode · 3.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_remote_client_request_params.pycode · 5.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_schema_drift_guard.pycode · 2.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_scope_read_consistency.pycode · 19.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_scoped_blocks.pycode · 40.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_search_all_users.pycode · 41.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_search_single_user_core_memory.pycode · 9.4 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_session_experience_distillation.pycode · 28.3 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_session_id.pycode · 23.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_session_id_integration.pycode · 5.8 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_skill_cli_tools.pycode · 3.6 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_skill_edit_budget.pycode · 22.7 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_skill_experience.pycode · 28.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_skill_orm.pycode · 1.1 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_skill_schema.pycode · 6.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_temporal_queries.pycode · 13.9 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_user.pycode · 10.2 KB
No inline preview for this entry.
mirix-personal-memory-agent/tests/test_user_manager.pycode · 20.5 KB
No inline preview for this entry.
mirix-personal-memory-agent/uv.locktext · 1148.0 KB
No inline preview for this entry.

1. Definitions

2. Ownership and Grant of License

a. Your Rights

b. License to MIRIX Project Owner

c. No Reciprocal Commercial Rights

3. Representations and Warranties

4. Patent License

5. Disclaimer of Warranty

6. Public Record

7. Governing Law

8. Entire Agreement

Signature Section

A. Individual Contributor

B. Corporate Contributor

MIRIX - Claude Code Instructions

What This Project Does

Key Architecture

Local Development Setup

Prerequisites

Start Infrastructure

Run API Locally (without Docker)

Access Points

Running Tests

Common Dev Tasks

Add a new API endpoint

Add a new memory type

Format & lint

Async Rules (Critical)

Commit Convention

Do Not

Contributor Covenant Code of Conduct

Our Pledge

Our Standards

Enforcement Responsibilities

Scope

Enforcement

Enforcement Guidelines

1. Correction

2. Warning

3. Temporary Ban

4. Permanent Ban

Attribution

MIRIX Code Standards

Code Formatting and Style

Formatting Tools

Style Guidelines

Editor Configuration

Running Formatting Tools

IDE Setup

Contributing to MIRIX

Four Ways to Get Involved

Help With Existing Issues

Create Your Own Tickets

Share Your Use Cases

Help Others in Discord

What happens next?

Notes for Large Changes

Setup

Making Changes

Submitting Changes

Pull Request Guidelines

Code Style and Quality

Third-Party Integrations

Optional Dependencies

Integration Structure

Testing

Questions?