Trace how your organization's decisions were made. Ask one question and reconstruct the full decision journey across Slack, Gmail, meetings, and final documentation.

Memora is an organizational memory and decision intelligence platform that combines real-time communication data with structured documentation to answer "Why did we decide this?" questions.

Instead of scrolling through months of Slack threads and email chains, Memora:

1. Ingests Slack conversations, Gmail threads, meeting notes, and final decisions
2. Embeds everything into a semantic vector database (ChromaDB)
3. Retrieves relevant evidence using semantic search
4. Ranks sources by organizational weight (Final Document > Meeting > Email > Slack)
5. Reasons with Gemini AI to synthesize a grounded explanation
6. Traces back to the original sources with full provenance

• 🔍 Lost institutional knowledge — "Why did we choose FastAPI?"
• ⏰ Decision archaeology — Decisions disappear from Slack after 30 days
• 🤝 Onboarding friction — New team members can't find decision rationale
• 📊 Audit trails — No clear evidence of how decisions were made
• 🧩 Scattered context — Decision history lives in 5+ different places

• Only fetches new messages since last sync (no full resets)
• Deduplicates automatically
• Tracks sync state in data/sync_state.json
• No wasted API calls

• Slack — Real-time channel discussions
• Gmail — Email thread context and formal decisions
• Meeting Notes — Structured discussion points
• Final Documents — Authoritative decision records

Final Document (strongest authority)
    ↓
Meeting Notes (consensus discussion)
    ↓
Gmail Threads (formal reasoning)
    ↓
Slack (informal context)

• Powered by Google Gemini Embedding-001 for semantic understanding
• Gemini 2.5 Flash for reasoning and synthesis
• ChromaDB for sub-millisecond vector search

• Evidence cards with source provenance
• Reasoning timeline showing how decisions evolved
• Confidence scoring based on source diversity
• Full traceability — click any source to see original context

• Manual "Sync Now" button for on-demand updates
• Auto-sync every 60-120 seconds (configurable)
• Last sync timestamp visible in sidebar
• Real-time status feedback

• Unified view — Single "All" tab shows combined records from all sources (Slack, Gmail, meetings, documents)
• Per-source filtering — Switch to individual source tabs for focused browsing
• Full-text reading — Always show complete source content in the detail pane
• Quick identification — Count badges on tabs show results per source
• Clear selection — Highlighted cards with visual accent bar make selection obvious
• Internal scrolling — Clean, compact record list with smooth pagination
• Source badges — Quick visual distinction of record origin (Slack, Gmail, Meeting, Document)
• Responsive layout — Reader pane dominates the right side for better scanning

┌─────────────────────────────────────────────────────────────┐
│                    Memora Application                        │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Frontend (Streamlit)                                        │
│  ├─ Query Interface                                          │
│  ├─ Evidence Cards                                           │
│  ├─ Decision Timeline                                        │
│  └─ Sync Control Panel                                       │
│                                                               │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Ingestion Pipeline                                          │
│  ├─ fetch_slack.py ──────► Slack API                        │
│  ├─ fetch_gmail.py ──────► Gmail API                        │
│  └─ ingest.py                                                │
│      ├─ Semantic Chunking                                    │
│      ├─ Gemini Embeddings                                    │
│      └─ ChromaDB Upsert                                      │
│                                                               │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Vector Store (ChromaDB)                                     │
│  ├─ slack_messages                                           │
│  ├─ gmail_messages                                           │
│  ├─ meeting_notes (chunked)                                  │
│  └─ final_documents (chunked)                                │
│                                                               │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Reasoning Engine                                            │
│  ├─ Retrieval (semantic search)                              │
│  ├─ Ranking (source priority)                                │
│  └─ Synthesis (Gemini reasoning)                             │
│                                                               │
└─────────────────────────────────────────────────────────────┘

• Python 3.8+
• Google Cloud credentials (Gmail API, Gemini API)
• Slack Bot Token
• Internet connection

git clone https://github.com/yourusername/memora.git
cd memora
pip install -r requirements.txt

Create a .env file in the root directory:

# Google APIs
GEMINI_API_KEY=your_gemini_api_key_here
GMAIL_GROUP=[email protected]

# Slack
SLACK_TOKEN=xoxb-your-slack-bot-token
SLACK_CHANNEL=all-memora-labs

# Authentication (optional but recommended)
ADMIN_EMAIL=[email protected]

Place credentials.json in the root directory (from Google Cloud Console OAuth 2.0 setup):

# First run creates token.json after browser auth
python fetch_gmail.py

# Fetches current Slack messages, Gmail threads, and ingests static docs
python ingest.py

This creates:

• chroma_data/ — Vector store with embeddings
• data/raw/ — Raw JSON from Slack/Gmail
• data/sync_state.json — Tracks last sync timestamp

streamlit run app.py

Visit http://localhost:8501 in your browser.

Step 1: Retrieval

Query: "Why did we choose FastAPI over MERN/Node?"
↓
ChromaDB semantic search returns:
  ✓ Slack: @alice "FastAPI is async-first"
  ✓ Meeting Notes: "Team consensus on FastAPI"
  ✓ Gmail: "Final decision approved FastAPI"
  ✓ Final Document: "Tech Stack: FastAPI + React"

Step 2: Ranking

Sources prioritized by weight:
  1st ⭐⭐⭐ Final Document (authoritative)
  2nd ⭐⭐  Meeting Notes (consensus)
  3rd ⭐   Gmail (formal reasoning)
  4th      Slack (informal context)

Step 3: Reasoning

Gemini synthesizes:
  "We chose FastAPI because:
   - Async performance (Slack discussion)
   - Team consensus in meeting
   - Formally approved in final document
   - Confidence: High"

Step 4: Traceability

User clicks "Final Document" →
  Reads full context immediately
User clicks "Meeting Notes" →
  Sees exact discussion points
User clicks "Gmail" →
  Reads formal approval email

memora/
├── app.py                      # Main Streamlit application
├── ingest.py                   # Incremental ingestion pipeline
├── fetch_slack.py              # Slack API integration
├── fetch_gmail.py              # Gmail API integration
├── requirements.txt            # Python dependencies
├── credentials.json            # Google OAuth (⚠️ gitignore)
├── token.json                  # Gmail token (⚠️ gitignore)
│
├── data/
│   ├── raw/
│   │   ├── slack_messages.json
│   │   ├── slack_users.json
│   │   ├── gmail_messages.json
│   │   ├── gmail_threads.json
│   │   ├── meeting_notes.txt
│   │   └── final_document.txt
│   ├── sync_state.json         # Tracks last sync timestamps
│   └── config.json
│
├── chroma_data/                # Vector store (persistent)
│   └── [auto-created]
│
├── pages/
│   ├── 1_Login.py             # Authentication page
│   ├── 2_My_Organization.py   # Org settings page
│   └── source_explorer.py     # Browse sources
│
├── utils/
│   └── auth.py                # Session management
│
└── README.md

In the Streamlit sidebar, select sync frequency:

• 60 sec — Check for new messages very frequently
• 90 sec — Balanced (default)
• 120 sec — Less frequent network calls

Place these in data/raw/ for one-time ingestion:

• meeting_notes.txt — Structured meeting minutes
• final_document.txt — Decision records

Set in .env:

SLACK_CHANNEL=important-decisions

Set in .env:

GMAIL_GROUP=[email protected]

Before (❌ Full Reset)

# Old approach: wasteful
reset_chroma()  # Delete everything
fetch_all_slack()
fetch_all_gmail()
re-embed everything

After (✅ Incremental)

# New approach: efficient
last_ts = load_sync_state()["slack"]["last_ts"]
new_messages = fetch_slack(oldest=last_ts)
upsert(new_messages)  # Only add new docs
save_sync_state(last_ts)

Benefits:

• ⚡ 10-100x faster (only new items)
• 💰 Fewer API calls
• 🔄 No downtime for ingestion
• 📊 Full history preserved

Why ChromaDB?

• ✅ Persistent local storage
• ✅ Semantic search (cosine similarity)
• ✅ Metadata filtering
• ✅ No external dependencies (SQLite)

Schema:

{
  "id": "slack_1712742600.123456",
  "document": "Complete message text...",
  "metadata": {
    "source": "slack",
    "channel": "general",
    "user": "U123456",
    "user_name": "Alice",
    "ts": "1712742600.123456"
  }
}

Embeddings:

• Model: gemini-embedding-001
• Dimension: 768
• Update: Only on new documents (incremental)

Ranking Function:

def source_priority(source: str) -> int:
    return {
        "final_document": 1,      # Strongest
        "meeting": 2,
        "gmail": 3,
        "slack": 4,               # Weakest
    }.get(source, 99)

Ingest static files manually:

from ingest import run_incremental_ingestion

result = run_incremental_ingestion(include_static_docs=True)
# Returns: {"new_slack": 5, "new_gmail": 3, "meeting_chunks": 12, ...}

from chromadb import PersistentClient

client = PersistentClient(path="./chroma_data")
collection = client.get_collection("org_memory")

results = collection.query(
    query_texts=["Why did we choose FastAPI?"],
    n_results=5
)

Edit the prompt in app.py (around line 700) to change reasoning behavior:

prompt = f"""
You are Memora, an organizational reasoning engine.

[Customize instructions here]

Evidence:
{context}
"""

• Slack messages & emails are sensitive
• Store credentials.json and token.json in .gitignore
• Use environment variables for API keys
• Implement row-level access control in utils/auth.py

• Built-in session management
• Role-based access (Admin, Member, Viewer)
• User profile stored in st.session_state

Every decision answer includes:

• Source documents
• Retrieval confidence
• Timestamp of analysis

• Slack + Gmail integration
• Incremental sync
• Vector search & ranking
• Gemini reasoning
• Decision traceability

• Calendar integration (calendar events as context)
• Jira/Linear issue tracking
• Slack thread replies (nested discussions)
• Multi-org support
• Advanced filtering (date range, users, channels)

• Decision workflow automation
• Confidence scoring ML model
• Custom LLM fine-tuning
• GraphQL API for external tools
• Slack bot for inline answers

Q: "Why did we choose React over Vue?" A: Best explanation sourced from Final Document + Meeting Notes + Gmail + Slack

Q: "How did we decide on our deployment pipeline?" A: Timeline shows Slack discussions → Email approvals → Meeting consensus → Final doc

Q: "What was the rationale for microservices?" A: Ranks sources by authority; explains evolution of thinking

Contributions welcome! To add features:

1. Fork the repo
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make changes (update tests if needed)
4. Commit (git commit -m 'Add amazing feature')
5. Push (git push origin feature/amazing-feature)
6. Open a Pull Request

This project is licensed under the MIT License — see LICENSE.md for details.

• Documentation: See DESIGN.md for UI/UX specs
• Issues: Open a GitHub issue for bugs
• Discussions: Start a discussion for feature requests
• Email: [email protected]

Built with ❤️ for organizational transparency and decision intelligence.

Technologies:

• Streamlit — UI framework
• ChromaDB — Vector database
• Google Gemini — LLM & embeddings
• Slack SDK — Slack integration
• Google API Client — Gmail integration

• Lines of Code: ~2000
• API Integrations: 3 (Slack, Gmail, Gemini)
• Vector Dimensions: 768
• Supported Data Sources: 2 (+ static)
• Reasoning Model: Gemini 2.5 Flash
• Database: ChromaDB + SQLite

Made with 🧠 for better organizational memory.

⬆ Back to Top