google-keep-notes-mcp 0.1.2__py3-none-any.whl

google_keep_notes_mcp-0.1.2.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: google-keep-notes-mcp
+Version: 0.1.2
+Summary: MCP server for Google Keep
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gkeepapi>=0.17.1
+Requires-Dist: google-api-python-client>=2.198.0
+Requires-Dist: google-auth-oauthlib>=1.4.0
+Requires-Dist: markdown>=3.10.2
+Requires-Dist: mcp>=1.28.1
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: reportlab>=5.0.0
+Dynamic: license-file
+
+# Google Keep MCP
+
+Google Keep MCP is a Model Context Protocol server that lets MCP-capable clients create, read, update, search, archive, and export Google Keep notes.
+
+## What this project is
+
+- Installable as a normal Python package
+- Usable from Claude Desktop, Cursor, and any other MCP client
+- Designed so each user logs in with their own Google Keep account
+- Stores login state locally on each user machine
+
+## Install
+
+### With uv
+
+```powershell
+uv add google-keep-mcp
+```
+
+### With pip
+
+```powershell
+pip install google-keep-mcp
+```
+
+### From this repo for local testing
+
+```powershell
+cd D:\MyWorld\google-Keep-MCP
+uv pip install -e .
+```
+
+## Run
+
+After install, run the server command:
+
+```powershell
+google-keep-mcp
+```
+
+For local repo testing you can also run it through uv:
+
+```powershell
+uv run --directory D:\MyWorld\google-Keep-MCP google-keep-mcp
+```
+
+## First-time login
+
+Each user must log in once on their own machine.
+
+Run:
+
+```powershell
+google-keep-mcp login
+```
+
+Then enter:
+
+- your Google email
+- your Google Keep master token
+
+The login is saved locally in:
+
+- Windows: `C:\Users\<you>\.google_keep_mcp\config.json`
+- macOS/Linux: `~/.google_keep_mcp/config.json`
+
+If the token is revoked or removed, the user must log in again.
+
+## Claude Desktop config
+
+For local testing, point Claude Desktop to the installed command:
+
+```json
+{
+  "mcpServers": {
+    "google-keep": {
+      "command": "D:\\MyWorld\\google-Keep-MCP\\.venv-test\\Scripts\\google-keep-mcp.exe"
+    }
+  }
+}
+```
+
+If the package is installed globally or into the active environment, this also works:
+
+```json
+{
+  "mcpServers": {
+    "google-keep": {
+      "command": "google-keep-mcp"
+    }
+  }
+}
+```
+
+## Google Tasks reminders
+
+Reminder tools use Google Tasks OAuth credentials.
+
+Place the credentials file here:
+
+```text
+C:\Users\<you>\.google_keep_mcp\credentials.json
+```
+
+The reminder token is cached here:
+
+```text
+C:\Users\<you>\.google_keep_mcp\token.json
+```
+
+## What new users need
+
+- Install the package
+- Run `google-keep-mcp login`
+- Paste their own Google Keep master token
+- Then use the MCP server from Claude or any other MCP client
+
+## Public release note
+
+This package is ready to publish to PyPI, but it is not public until you upload it with your PyPI account.
+
+## License
+
+MIT

google_keep_notes_mcp-0.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+google_keep_notes_mcp-0.1.2.dist-info/licenses/LICENSE,sha256=QrmQfISYGX9OtpEhqdkMmlEOWeg8UZrjvYLt0FmMUb0,1093
+keep_mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keep_mcp_server/auth.py,sha256=JqB0zRQZc9iSKJbZjogpAtEF-CQs1BAgpDqNpDrbdyM,1038
+keep_mcp_server/config.py,sha256=4dPN9_1HBd0REtX14UF1VUCOZcTTr3Epbzpvhb56jek,705
+keep_mcp_server/export_tools.py,sha256=Wk2cQYKcIE2Xw4cz5quUJP3JN5sfW8fsyDYSH488pfQ,3474
+keep_mcp_server/keep_tools.py,sha256=v61tmp0-yjKawuATxtGQgOSpin662KafOCsPGaroGJg,13001
+keep_mcp_server/server.py,sha256=Ze_-tAOZ2kcOEQ0RsApXllVvIrn4rkbN4EV_mHSCuIY,3809
+keep_mcp_server/tasks_tools.py,sha256=jciMpdip5tRwV0V7afTCnE_hLqb4rofkfKFHM6_O6l0,2490
+google_keep_notes_mcp-0.1.2.dist-info/METADATA,sha256=_ckgNcO5BpD_NYIUd-uVftaycIVdB72Ciod5SBzJIRQ,2929
+google_keep_notes_mcp-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+google_keep_notes_mcp-0.1.2.dist-info/entry_points.txt,sha256=50Fai_GxVEwOZNEE3WA3lfPZ21XN3Ko8m9Vx2DRraJs,64
+google_keep_notes_mcp-0.1.2.dist-info/top_level.txt,sha256=nYo2wQPpQQ11hkVtMVlCoJfgsdd5IT0MDS1AQfIzsXY,16
+google_keep_notes_mcp-0.1.2.dist-info/RECORD,,

google_keep_notes_mcp-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

google_keep_notes_mcp-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+google-keep-mcp = keep_mcp_server.server:main

google_keep_notes_mcp-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Muhammad Abubakar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

google_keep_notes_mcp-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+keep_mcp_server

keep_mcp_server/auth.py

@@ -0,0 +1,38 @@
+import os
+import gkeepapi
+from dotenv import load_dotenv
+from .config import load_config, save_config
+
+load_dotenv()
+
+
+def get_keep_client() -> gkeepapi.Keep:
+    config = load_config()
+
+    email = os.getenv("GOOGLE_EMAIL") or config.get("google_email")
+    master_token = os.getenv("GOOGLE_MASTER_TOKEN") or config.get("google_master_token")
+
+    if not email or not master_token:
+        raise ValueError(
+            "Google Keep auth not configured. Run `google-keep-mcp login` first "
+            "or set GOOGLE_EMAIL and GOOGLE_MASTER_TOKEN."
+        )
+
+    keep = gkeepapi.Keep()
+
+    try:
+        keep.authenticate(email, master_token)
+        print(f"[auth] Login successful: {email}")
+    except Exception as error:
+        raise RuntimeError(f"[auth] Authentication failed: {error}")
+
+    return keep
+
+
+def save_keep_login(email: str, master_token: str) -> None:
+    save_config(
+        {
+            "google_email": email,
+            "google_master_token": master_token,
+        }
+    )

keep_mcp_server/config.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+
+
+APP_DIR = Path.home() / ".google_keep_mcp"
+CONFIG_FILE = APP_DIR / "config.json"
+TASKS_TOKEN_FILE = APP_DIR / "token.json"
+TASKS_CREDENTIALS_FILE = APP_DIR / "credentials.json"
+
+
+def ensure_app_dir() -> None:
+    APP_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    if not CONFIG_FILE.exists():
+        return {}
+    try:
+        with CONFIG_FILE.open("r", encoding="utf-8") as file:
+            return json.load(file)
+    except Exception:
+        return {}
+
+
+def save_config(data: dict) -> None:
+    ensure_app_dir()
+    with CONFIG_FILE.open("w", encoding="utf-8") as file:
+        json.dump(data, file, indent=2)

keep_mcp_server/export_tools.py

@@ -0,0 +1,108 @@
+import os
+from pathlib import Path
+from datetime import datetime
+
+
+def get_export_path(filename: str) -> str:
+    """Export folder — Desktop pe save hoga"""
+    desktop = Path.home() / "Desktop" / "KeepExports"
+    desktop.mkdir(parents=True, exist_ok=True)
+    return str(desktop / filename)
+
+
+def export_as_pdf(title: str, content: str) -> str:
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+    from reportlab.lib.enums import TA_LEFT
+
+    safe_title = "".join(c for c in title if c.isalnum() or c in " _-").strip()
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{safe_title}_{timestamp}.pdf"
+    filepath = get_export_path(filename)
+
+    doc = SimpleDocTemplate(filepath, pagesize=A4,
+                            rightMargin=inch, leftMargin=inch,
+                            topMargin=inch, bottomMargin=inch)
+
+    styles = getSampleStyleSheet()
+    title_style = ParagraphStyle('Title', parent=styles['Title'], fontSize=18, spaceAfter=20)
+    body_style = ParagraphStyle('Body', parent=styles['Normal'], fontSize=11,
+                                leading=16, spaceAfter=8)
+
+    story = []
+    story.append(Paragraph(title, title_style))
+    story.append(Spacer(1, 0.2 * inch))
+
+    for line in content.split('\n'):
+        line = line.strip()
+        if line:
+            story.append(Paragraph(line, body_style))
+        else:
+            story.append(Spacer(1, 0.1 * inch))
+
+    doc.build(story)
+    return filepath
+
+
+def export_as_docx(title: str, content: str) -> str:
+    from docx import Document
+    from docx.shared import Pt, Inches
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+    safe_title = "".join(c for c in title if c.isalnum() or c in " _-").strip()
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{safe_title}_{timestamp}.docx"
+    filepath = get_export_path(filename)
+
+    doc = Document()
+
+    # Title
+    title_para = doc.add_heading(title, level=1)
+    title_para.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
+    doc.add_paragraph()
+
+    # Content
+    for line in content.split('\n'):
+        doc.add_paragraph(line)
+
+    doc.save(filepath)
+    return filepath
+
+
+def export_as_markdown(title: str, content: str) -> str:
+    safe_title = "".join(c for c in title if c.isalnum() or c in " _-").strip()
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{safe_title}_{timestamp}.md"
+    filepath = get_export_path(filename)
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(f"# {title}\n\n")
+        f.write(content)
+
+    return filepath
+
+
+def export_note(title: str, content: str, format: str = "pdf") -> dict:
+    """
+    format: 'pdf', 'docx', 'md'
+    """
+    format = format.lower().strip()
+
+    if format == "pdf":
+        filepath = export_as_pdf(title, content)
+    elif format in ("docx", "word"):
+        filepath = export_as_docx(title, content)
+    elif format in ("md", "markdown"):
+        filepath = export_as_markdown(title, content)
+    else:
+        raise ValueError(f"Unsupported format: {format}. Use: pdf, docx, md")
+
+    return {
+        "exported": True,
+        "format": format,
+        "title": title,
+        "filepath": filepath
+    }

keep_mcp_server/keep_tools.py

@@ -0,0 +1,461 @@
+import gkeepapi
+from keep_mcp_server.auth import get_keep_client
+
+keep = None
+
+def get_keep():
+    global keep
+    if keep is None:
+        keep = get_keep_client()
+    return keep
+
+
+def create_note(title: str, content: str = "") -> dict:
+    k = get_keep()
+    note = k.createNote(title, content)
+    k.sync()
+    return {"id": note.id, "title": note.title, "content": note.text}
+
+
+def list_notes(query: str = None) -> list:
+    k = get_keep()
+    k.sync()
+    if query:
+        notes = k.find(query=query)
+    else:
+        notes = k.all()
+    result = []
+    for note in notes:
+        if not note.trashed and not note.archived:
+            result.append({
+                "id": note.id,
+                "title": note.title,
+                "content": note.text,
+                "pinned": note.pinned,
+                "color": str(note.color),
+            })
+    return result
+
+
+def get_note(note_id: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    return {"id": note.id, "title": note.title, "content": note.text}
+
+
+def update_note(note_id: str, title: str = None, content: str = None) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    if title is not None:
+        note.title = title
+    if content is not None:
+        note.text = content
+    k.sync()
+    return {"id": note.id, "title": note.title, "content": note.text}
+
+
+def delete_note(note_id: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    note.trash()
+    k.sync()
+    return {"deleted": True, "id": note_id}
+
+
+def archive_note(note_id: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    note.archived = True
+    k.sync()
+    return {"archived": True, "id": note_id}
+
+
+def search_notes(keyword: str) -> list:
+    k = get_keep()
+    k.sync()
+    notes = k.find(query=keyword)
+    result = []
+    for note in notes:
+        if not note.trashed:
+            result.append({
+                "id": note.id,
+                "title": note.title,
+                "content": note.text,
+            })
+    return result
+
+def set_reminder(note_id: str, reminder_time: str) -> dict:
+    """reminder_time format: 'YYYY-MM-DD HH:MM'"""
+    from keep_mcp_server.tasks_tools import create_reminder_task
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+
+    note_url = note.url or f"https://keep.google.com/u/0/#NOTE/{note.id}"
+    result = create_reminder_task(note.title, note_url, reminder_time)
+
+    return {
+        "note_id": note_id,
+        "reminder_set": reminder_time,
+        "task_created": result
+    }
+
+def pin_note(note_id: str, pinned: bool = True) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    note.pinned = pinned
+    k.sync()
+    return {"id": note_id, "pinned": pinned}
+
+
+def change_color(note_id: str, color: str) -> dict:
+    """colors: red, blue, green, yellow, white, gray, teal, pink, purple, brown"""
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    color_map = {
+        "red": gkeepapi.node.ColorValue.Red,
+        "blue": gkeepapi.node.ColorValue.Blue,
+        "green": gkeepapi.node.ColorValue.Green,
+        "yellow": gkeepapi.node.ColorValue.Yellow,
+        "white": gkeepapi.node.ColorValue.White,
+        "gray": gkeepapi.node.ColorValue.Gray,
+        "teal": gkeepapi.node.ColorValue.Teal,
+        "pink": gkeepapi.node.ColorValue.Pink,
+        "purple": gkeepapi.node.ColorValue.Purple,
+        "brown": gkeepapi.node.ColorValue.Brown,
+    }
+    if color.lower() not in color_map:
+        raise ValueError(f"Invalid color. Choose from: {list(color_map.keys())}")
+    note.color = color_map[color.lower()]
+    k.sync()
+    return {"id": note_id, "color": color}
+
+def add_collaborator(note_id: str, email: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    note.collaborators.add(email)
+    k.sync()
+    return {"note_id": note_id, "collaborator_added": email}
+
+
+def remove_collaborator(note_id: str, email: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    note.collaborators.remove(email)
+    k.sync()
+    return {"note_id": note_id, "collaborator_removed": email}
+
+def create_label(name: str) -> dict:
+    k = get_keep()
+    label = k.findLabel(name)
+    if label:
+        return {"id": label.id, "name": label.name, "already_existed": True}
+    label = k.createLabel(name)
+    k.sync()
+    return {"id": label.id, "name": label.name, "already_existed": False}
+
+
+def add_label_to_note(note_id: str, label_name: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    label = k.findLabel(label_name)
+    if not label:
+        label = k.createLabel(label_name)
+    note.labels.add(label)
+    k.sync()
+    return {"note_id": note_id, "label_added": label_name}
+
+
+def remove_label_from_note(note_id: str, label_name: str) -> dict:
+    k = get_keep()
+    note = k.get(note_id)
+    if not note:
+        raise ValueError(f"Note not found: {note_id}")
+    label = k.findLabel(label_name)
+    if not label:
+        raise ValueError(f"Label not found: {label_name}")
+    note.labels.remove(label)
+    k.sync()
+    return {"note_id": note_id, "label_removed": label_name}
+
+
+def list_labels() -> list:
+    k = get_keep()
+    return [{"id": l.id, "name": l.name} for l in k.labels()]
+
+def get_notes_analytics() -> dict:
+    """Detailed analytics of all Google Keep notes"""
+    from datetime import datetime, timezone
+    from collections import Counter
+    
+    k = get_keep()
+    k.sync()
+    all_notes = [n for n in k.all() if not n.trashed]
+    active = [n for n in all_notes if not n.archived]
+    archived = [n for n in all_notes if n.archived]
+    
+    # Label stats
+    label_counter = Counter()
+    for note in active:
+        for label in note.labels.all():
+            label_counter[label.name] += 1
+    
+    # Color stats
+    color_counter = Counter()
+    for note in active:
+        color_counter[str(note.color).replace("ColorValue.", "")] += 1
+    
+    # Oldest & newest note
+    dated_notes = [n for n in active if n.timestamps.created]
+    oldest = min(dated_notes, key=lambda n: n.timestamps.created) if dated_notes else None
+    newest = max(dated_notes, key=lambda n: n.timestamps.created) if dated_notes else None
+    
+    # Pinned count
+    pinned = [n for n in active if n.pinned]
+    
+    # Notes with content vs empty
+    with_content = [n for n in active if n.text and n.text.strip()]
+    
+    return {
+        "total_notes": len(active),
+        "archived_notes": len(archived),
+        "pinned_notes": len(pinned),
+        "notes_with_content": len(with_content),
+        "empty_notes": len(active) - len(with_content),
+        "most_used_labels": [
+            {"label": k, "count": v} 
+            for k, v in label_counter.most_common(5)
+        ],
+        "color_distribution": dict(color_counter),
+        "oldest_note": {
+            "title": oldest.title or "Untitled",
+            "created": oldest.timestamps.created.strftime("%B %Y")
+        } if oldest else None,
+        "newest_note": {
+            "title": newest.title or "Untitled", 
+            "created": newest.timestamps.created.strftime("%B %Y")
+        } if newest else None,
+    }
+
+TEMPLATES = {
+    "meeting": {
+        "title": "Meeting Notes — {date}",
+        "content": """👥 Attendees:
+- 
+
+🎯 Agenda:
+- 
+
+📝 Discussion Points:
+- 
+
+✅ Action Items:
+- [ ] 
+
+⏰ Next Meeting:
+
+📌 Notes:
+"""
+    },
+    "journal": {
+        "title": "Daily Journal — {date}",
+        "content": """🌅 Today I am grateful for:
+- 
+
+📋 Today's Goals:
+- [ ] 
+- [ ] 
+- [ ] 
+
+💭 How I'm feeling:
+
+📝 Today's highlights:
+
+🌙 End of day reflection:
+"""
+    },
+    "project": {
+        "title": "Project Plan — {name}",
+        "content": """🎯 Project Goal:
+
+📅 Deadline:
+
+✅ Tasks:
+- [ ] 
+- [ ] 
+- [ ] 
+
+👥 Team Members:
+
+⚠️ Risks:
+
+📊 Progress:
+[ ] Planning
+[ ] In Progress  
+[ ] Review
+[ ] Done
+
+📝 Notes:
+"""
+    },
+    "shopping": {
+        "title": "Shopping List — {date}",
+        "content": """🛒 Items to Buy:
+- [ ] 
+- [ ] 
+- [ ] 
+
+💰 Budget: 
+
+🏪 Store:
+
+📝 Notes:
+"""
+    },
+    "ideas": {
+        "title": "Ideas — {topic}",
+        "content": """💡 Main Idea:
+
+🔍 Details:
+
+✅ Pros:
+- 
+
+❌ Cons:
+- 
+
+🚀 Next Steps:
+- 
+
+📝 Notes:
+"""
+    }
+}
+
+
+def create_from_template(template_name: str, extra: str = "") -> dict:
+    """
+    Template se note banao.
+    template_name: meeting, journal, project, shopping, ideas
+    extra: project name ya topic (optional)
+    """
+    from datetime import datetime
+    
+    template_name = template_name.lower().strip()
+    
+    if template_name not in TEMPLATES:
+        available = list(TEMPLATES.keys())
+        raise ValueError(f"Template '{template_name}' nahi mila. Available: {available}")
+    
+    template = TEMPLATES[template_name]
+    date_str = datetime.now().strftime("%d %B %Y")
+    
+    title = template["title"].format(date=date_str, name=extra or "New Project", topic=extra or "New Ideas")
+    content = template["content"]
+    
+    k = get_keep()
+    note = k.createNote(title, content)
+    note.pinned = True
+    k.sync()
+    
+    return {
+        "id": note.id,
+        "title": note.title,
+        "template_used": template_name,
+        "content_preview": content[:100] + "..."
+    }
+
+
+def list_templates() -> list:
+    """Available templates ki list"""
+    return [
+        {"name": "meeting", "description": "Meeting notes with agenda, attendees, action items"},
+        {"name": "journal", "description": "Daily journal with goals and reflection"},
+        {"name": "project", "description": "Project plan with tasks, team, deadlines"},
+        {"name": "shopping", "description": "Shopping list with budget and store"},
+        {"name": "ideas", "description": "Ideas capture with pros, cons, next steps"},
+    ]
+
+
+def get_weekly_digest() -> dict:
+    """Smart daily/weekly digest of Google Keep notes"""
+    from datetime import datetime, timezone, timedelta
+
+    k = get_keep()
+    k.sync()
+    all_notes = [n for n in k.all() if not n.trashed and not n.archived]
+
+    now = datetime.now(timezone.utc)
+    week_ago = now - timedelta(days=7)
+    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+
+    pinned = []
+    recent_today = []
+    recent_week = []
+    by_label = {}
+
+    for note in all_notes:
+        note_data = {
+            "id": note.id,
+            "title": note.title or "Untitled",
+            "preview": note.text[:80] + "..." if len(note.text) > 80 else note.text,
+            "pinned": note.pinned,
+            "color": str(note.color).replace("ColorValue.", ""),
+            "labels": [l.name for l in note.labels.all()]
+        }
+
+        if note.pinned:
+            pinned.append(note_data)
+
+        if note.timestamps.updated:
+            if note.timestamps.updated >= today_start:
+                recent_today.append(note_data)
+            elif note.timestamps.updated >= week_ago:
+                recent_week.append(note_data)
+
+        for label in note.labels.all():
+            if label.name not in by_label:
+                by_label[label.name] = []
+            by_label[label.name].append(note_data)
+
+    # Most active label
+    most_active_label = max(by_label, key=lambda l: len(by_label[l])) if by_label else None
+
+    return {
+        "digest_date": now.strftime("%A, %d %B %Y"),
+        "summary": {
+            "total_active_notes": len(all_notes),
+            "pinned_count": len(pinned),
+            "updated_today": len(recent_today),
+            "updated_this_week": len(recent_week),
+            "total_labels": len(by_label),
+            "most_active_label": most_active_label,
+        },
+        "pinned_notes": pinned,
+        "updated_today": recent_today,
+        "updated_this_week": recent_week,
+        "notes_by_label": {
+            label: notes for label, notes in sorted(
+                by_label.items(), key=lambda x: len(x[1]), reverse=True
+            )
+        }
+    }

keep_mcp_server/server.py

@@ -0,0 +1,145 @@
+from mcp.server.fastmcp import FastMCP
+from keep_mcp_server.keep_tools import (
+    create_note, list_notes, get_note, update_note,
+    delete_note, archive_note, search_notes,
+    set_reminder, pin_note, change_color
+)
+from keep_mcp_server.export_tools import export_note
+from keep_mcp_server.auth import save_keep_login
+from keep_mcp_server.config import load_config
+
+mcp = FastMCP("Google Keep MCP")
+
+
+@mcp.tool()
+def keep_create_note(title: str, content: str = "") -> dict:
+    return create_note(title, content)
+
+
+@mcp.tool()
+def keep_list_notes() -> list:
+    return list_notes()
+
+
+@mcp.tool()
+def keep_get_note(note_id: str) -> dict:
+    return get_note(note_id)
+
+
+@mcp.tool()
+def keep_update_note(note_id: str, title: str = None, content: str = None) -> dict:
+    return update_note(note_id, title, content)
+
+
+@mcp.tool()
+def keep_delete_note(note_id: str) -> dict:
+    return delete_note(note_id)
+
+
+@mcp.tool()
+def keep_archive_note(note_id: str) -> dict:
+    return archive_note(note_id)
+
+
+@mcp.tool()
+def keep_search_notes(keyword: str) -> list:
+    return search_notes(keyword)
+
+
+@mcp.tool()
+def keep_set_reminder(note_id: str, reminder_time: str) -> dict:
+    return set_reminder(note_id, reminder_time)
+
+
+@mcp.tool()
+def keep_pin_note(note_id: str, pinned: bool = True) -> dict:
+    return pin_note(note_id, pinned)
+
+
+@mcp.tool()
+def keep_change_color(note_id: str, color: str) -> dict:
+    return change_color(note_id, color)
+
+
+@mcp.tool()
+def keep_export_note(note_id: str, format: str = "pdf") -> dict:
+    from keep_mcp_server.keep_tools import get_note
+    note = get_note(note_id)
+    return export_note(note["title"], note["content"], format)
+
+
+@mcp.tool()
+def keep_add_collaborator(note_id: str, email: str) -> dict:
+    from keep_mcp_server.keep_tools import add_collaborator
+    return add_collaborator(note_id, email)
+
+
+@mcp.tool()
+def keep_remove_collaborator(note_id: str, email: str) -> dict:
+    from keep_mcp_server.keep_tools import remove_collaborator
+    return remove_collaborator(note_id, email)
+
+
+@mcp.tool()
+def keep_create_label(name: str) -> dict:
+    from keep_mcp_server.keep_tools import create_label
+    return create_label(name)
+
+
+@mcp.tool()
+def keep_add_label(note_id: str, label_name: str) -> dict:
+    from keep_mcp_server.keep_tools import add_label_to_note
+    return add_label_to_note(note_id, label_name)
+
+
+@mcp.tool()
+def keep_remove_label(note_id: str, label_name: str) -> dict:
+    from keep_mcp_server.keep_tools import remove_label_from_note
+    return remove_label_from_note(note_id, label_name)
+
+
+@mcp.tool()
+def keep_list_labels() -> list:
+    from keep_mcp_server.keep_tools import list_labels
+    return list_labels()
+
+
+@mcp.tool()
+def keep_get_analytics() -> dict:
+    from keep_mcp_server.keep_tools import get_notes_analytics
+    return get_notes_analytics()
+
+
+@mcp.tool()
+def keep_list_templates() -> list:
+    from keep_mcp_server.keep_tools import list_templates
+    return list_templates()
+
+
+@mcp.tool()
+def keep_create_from_template(template_name: str, extra: str = "") -> dict:
+    from keep_mcp_server.keep_tools import create_from_template
+    return create_from_template(template_name, extra)
+
+
+@mcp.tool()
+def keep_get_weekly_digest() -> dict:
+    from keep_mcp_server.keep_tools import get_weekly_digest
+    return get_weekly_digest()
+
+
+def main():
+    import sys
+
+    if len(sys.argv) >= 2 and sys.argv[1] == "login":
+        email = input("Google email: ").strip()
+        master_token = input("Google master token: ").strip()
+        save_keep_login(email, master_token)
+        print("Saved login to local config.")
+        return
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

keep_mcp_server/tasks_tools.py

@@ -0,0 +1,68 @@
+import os
+from datetime import datetime, timezone
+from dotenv import load_dotenv
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+from .config import TASKS_CREDENTIALS_FILE, TASKS_TOKEN_FILE, ensure_app_dir
+
+load_dotenv()
+
+SCOPES = ["https://www.googleapis.com/auth/tasks"]
+
+
+def get_tasks_service():
+    print("[tasks] OAuth check kar raha hai...")
+    creds = None
+
+    ensure_app_dir()
+
+    if TASKS_TOKEN_FILE.exists():
+        creds = Credentials.from_authorized_user_file(str(TASKS_TOKEN_FILE), SCOPES)
+        print("[tasks] Existing token mila")
+
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            print("[tasks] Token refresh ho raha hai...")
+            creds.refresh(Request())
+        else:
+            print("[tasks] Browser khul raha hai login ke liye...")
+            if not TASKS_CREDENTIALS_FILE.exists():
+                raise FileNotFoundError(
+                    f"Google Tasks credentials not found at {TASKS_CREDENTIALS_FILE}. "
+                    "Put your OAuth client credentials there."
+                )
+            flow = InstalledAppFlow.from_client_secrets_file(str(TASKS_CREDENTIALS_FILE), SCOPES)
+            creds = flow.run_local_server(port=0)
+
+        with TASKS_TOKEN_FILE.open("w", encoding="utf-8") as file:
+            file.write(creds.to_json())
+        print("[tasks] Token save ho gaya")
+
+    return build("tasks", "v1", credentials=creds)
+
+
+def create_reminder_task(note_title: str, note_url: str, reminder_time: str) -> dict:
+    service = get_tasks_service()
+
+    dt = datetime.strptime(reminder_time, "%Y-%m-%d %H:%M")
+    dt = dt.replace(tzinfo=timezone.utc)
+    due_rfc3339 = dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    safe_title = note_title.encode("ascii", "ignore").decode("ascii")
+    task_body = {
+        "title": f"Reminder: {safe_title} [Keep Note]",
+        "notes": str(note_url),
+        "due": due_rfc3339,
+    }
+
+    print(f"[tasks] Task bana raha hai: {task_body['title']}")
+    result = service.tasks().insert(tasklist="@default", body=task_body).execute()
+
+    return {
+        "task_id": str(result.get("id", "")),
+        "task_title": str(result.get("title", "")),
+        "due": str(result.get("due", "")),
+        "note_url": str(note_url),
+    }