Notion Research Documentation
OpenAIOfficialCreated by Notion Labs, IncDistributed by OpenAI
- Skill
- Content generator
- Automation and integrations
- MIT
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a systematic approach to gathering, analyzing, and documenting information stored within Notion. It guides the user through searching for relevant pages, extracting key facts and metrics, and synthesizing findings into structured formats such as quick briefs, comparisons, or comprehensive reports. The workflow includes specific steps for citation management and creating final documents directly within Notion, ensuring that all synthesized content remains linked to its original source material.
What it does
- Searches and fetches content from multiple Notion pages.
- Synthesizes research findings into structured document formats.
- Provides templates for briefs, summaries, comparisons, and reports.
- Manages citations and links back to original source pages.
- Supports updating existing Notion pages with new research or status changes.
- Includes a setup procedure for connecting the Notion MCP.
When to use it
- When you need to aggregate information from various Notion pages into a single report.
- When performing competitor analysis or technical investigations stored in Notion.
- When you need to compare options or features documented across different project pages.
- When creating executive-ready summaries or briefs from raw research notes.
Advantages
- Ensures consistent documentation structure across different research tasks.
- Maintains traceability by linking findings to original source pages.
- Reduces manual effort in formatting and organizing research data.
- Facilitates collaborative review by keeping synthesized reports within Notion.
Usage examples
- “Research our recent project meeting notes in Notion and create a summary of the key decisions made.”
- The agent searches for relevant meeting pages, extracts decision points, and creates a new summary page in Notion with citations.
- “Compare the two product feature proposals I have saved in Notion and draft a comparison report.”
- The agent fetches both proposals, identifies key tradeoffs, and generates a structured comparison document in Notion.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/openai/notion-research-documentation-lzcb/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip notion-research-documentation.zip -d .agents/skills
Documentation by Notion Labs, Inc
Research & Documentation
Pull relevant Notion pages, synthesize findings, and publish clear briefs or reports (with citations and links to sources).
Quick start
Find sources with
Notion:notion-searchusing targeted queries; confirm scope with the user.Fetch pages via
Notion:notion-fetch; note key sections and capture citations (reference/citations.md).Choose output format (brief, summary, comparison, comprehensive report) using
reference/format-selection-guide.md.Draft in Notion with
Notion:notion-create-pagesusing the matching template (quick, summary, comparison, comprehensive).Link sources and add a references/citations section; update as new info arrives with
Notion:notion-update-page.
Workflow
0) If any MCP call fails because Notion MCP is not connected, pause and set it up:
Add the Notion MCP:
codex mcp add notion --url https://mcp.notion.com/mcp
Enable remote MCP client:
Set
[features].rmcp_client = trueinconfig.tomlor runcodex --enable rmcp_client
Log in with OAuth:
codex mcp login notion
After successful login, the user will have to restart codex. You should finish your answer and tell them so when they try again they can continue with Step 1.
1) Gather sources
Search first (
Notion:notion-search); refine queries, and ask the user to confirm if multiple results appear.Fetch relevant pages (
Notion:notion-fetch), skim for facts, metrics, claims, constraints, and dates.Track each source URL/ID for later citation; prefer direct quotes for critical facts.
2) Select the format
Quick readout → quick brief.
Single-topic dive → research summary.
Option tradeoffs → comparison.
Deep dive / exec-ready → comprehensive report.
See
reference/format-selection-guide.mdfor when to pick each.
3) Synthesize
Outline before writing; group findings by themes/questions.
Note evidence with source IDs; flag gaps or contradictions.
Keep user goal in view (decision, summary, plan, recommendation).
4) Create the doc
Pick the matching template in
reference/(brief, summary, comparison, comprehensive) and adapt it.Create the page with
Notion:notion-create-pages; include title, summary, key findings, supporting evidence, and recommendations/next steps when relevant.Add citations inline and a references section; link back to source pages.
5) Finalize & handoff
Add highlights, risks, and open questions.
If the user needs follow-ups, create tasks or a checklist in the page; link any task database entries if applicable.
Share a short changelog or status using
Notion:notion-update-pagewhen updating.
References and examples
reference/— search tactics, format selection, templates, and citation rules (e.g.,advanced-search.md,format-selection-guide.md,research-summary-template.md,comparison-template.md,citations.md).examples/— end-to-end walkthroughs (e.g.,competitor-analysis.md,technical-investigation.md,market-research.md,trip-planning.md).
Files
- ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
- LICENSE.txt1.0 KiB
- SKILL.md3.3 KiB
- agents/openai.yaml497 B
- assets/notion-small.svg15.4 KiB
- assets/notion.png8.3 KiB
- evaluations/README.md4.2 KiB
- evaluations/basic-research.json1.7 KiB
- evaluations/research-to-database.json1.6 KiB
- examples/competitor-analysis.md8.0 KiB
- examples/market-research.md1.9 KiB
- examples/technical-investigation.md6.4 KiB
- examples/trip-planning.md3.7 KiB
- reference/advanced-search.md4.5 KiB
- reference/citations.md5.0 KiB
- reference/comparison-format.md870 B
- reference/comparison-template.md911 B
- reference/comprehensive-report-format.md1.1 KiB
- reference/comprehensive-report-template.md1.2 KiB
- reference/format-selection-guide.md2.7 KiB
- reference/quick-brief-format.md767 B
- reference/quick-brief-template.md473 B
- reference/research-summary-format.md841 B
- reference/research-summary-template.md1.1 KiB
examples/technical-investigation.md
Example: Technical Investigation
User Request
"Research our current caching strategy and create a technical summary"
Workflow Execution
Step 1: Search for Caching Information
Notion:notion-search
query: "caching strategy architecture"
query_type: "internal"
teamspace_id: "engineering-teamspace-id"Results Found:
"System Architecture Overview" (Engineering)
"Redis Implementation Guide" (Backend Docs)
"Performance Optimization - Q3 2024" (Engineering)
"API Caching Decision Record" (Architecture)
Step 2: Fetch Relevant Pages
Notion:notion-fetch
id: "system-architecture-page-url"Extracted: Current caching architecture uses Redis for API responses, Memcached for session storage.
Notion:notion-fetch
id: "redis-implementation-guide-url"Extracted: Implementation details, TTL settings, invalidation strategies.
Notion:notion-fetch
id: "api-caching-decision-record-url"Extracted: Why Redis was chosen over alternatives, trade-offs considered.
Step 3: Synthesize Findings
Key findings identified:
Two-tier caching: Redis (API responses) + Memcached (sessions)
TTL strategy: 5 minutes for dynamic data, 1 hour for static
Invalidation: Event-driven for critical updates
Performance impact: 75% reduction in database load
Known issues: Cache stampede on popular endpoints
Step 4: Create Technical Summary
Notion:notion-create-pages
parent: { page_id: "engineering-docs-parent-id" }
pages: [{
properties: {
"title": "Technical Summary: Caching Strategy - Oct 2025"
},
content: "[Structured technical summary using template]"
}]Output Document
# Technical Summary: Caching Strategy - Oct 2025
## Executive Summary
Our caching infrastructure uses a two-tier approach with Redis for API response caching and Memcached for session management. This strategy has reduced database load by 75% and improved API response times from 200ms to 50ms average.
## Architecture Overview
### Layer 1: API Response Caching (Redis)
**Technology**: Redis 7.0 cluster (3 nodes)
**Purpose**: Cache GET endpoint responses
**TTL Strategy**:
- Dynamic content: 5 minutes
- Static content: 1 hour
- User-specific: 15 minutes
**Source**: <mention-page url="...">System Architecture Overview</mention-page>
### Layer 2: Session Storage (Memcached)
**Technology**: Memcached 1.6
**Purpose**: User session data, temporary state
**TTL**: 24 hours (session lifetime)
## Implementation Details
### Cache Key Formatapi:v1:{endpoint}:{params_hash} session:{user_id}:{session_id}
### Invalidation Strategy
- **Event-driven**: Critical data changes trigger immediate invalidation
- **Time-based**: TTL expiration for non-critical data
- **Manual**: Admin tools for emergency cache clear
**Source**: <mention-page url="...">Redis Implementation Guide</mention-page>
## Decision Rationale
### Why Redis for API Caching?
**Pros**:
- Advanced data structures (sorted sets, hashes)
- Built-in TTL with automatic eviction
- Pub/sub for cache invalidation events
- Persistence options for durability
**Cons**:
- Higher memory usage than Memcached
- More complex cluster management
**Decision**: Chosen for flexibility and rich feature set needed for API caching.
**Source**: <mention-page url="...">API Caching Decision Record</mention-page>
### Why Memcached for Sessions?
**Pros**:
- Simpler, lighter weight
- Excellent for key-value storage
- Lower memory footprint
**Cons**:
- No persistence
- Limited data structures
**Decision**: Perfect fit for ephemeral session data where simplicity is valued.
## Performance Impact
| Metric | Before Caching | After Caching | Improvement |
|--------|----------------|---------------|-------------|
| Avg Response Time | 200ms | 50ms | 75% faster |
| Database Load | 100% | 25% | 75% reduction |
| Cache Hit Rate | - | 85% | - |
| Peak RPS Handled | 1,000 | 4,000 | 4x increase |
**Source**: <mention-page url="...">Performance Optimization - Q3 2024</mention-page>
## Known Issues & Limitations
### Cache Stampede
**Issue**: When popular cache entries expire, multiple requests hit database simultaneously
**Mitigation**: Implemented probabilistic early expiration and request coalescing
**Status**: Reduced by 90% but not eliminated
### Stale Data Risk
**Issue**: Cached data can be up to TTL duration stale
**Mitigation**: Event-driven invalidation for critical data paths
**Status**: Acceptable trade-off for performance gains
## Monitoring & Observability
**Metrics tracked**:
- Cache hit/miss rates per endpoint
- Memory usage and eviction rates
- Response time distributions
- Invalidation event frequency
**Tools**: DataDog dashboards, CloudWatch alarms
## Future Considerations
1. **Edge Caching**: Evaluate CDN integration for static assets
2. **Cache Warming**: Pre-populate cache for predictable traffic spikes
3. **Adaptive TTLs**: Adjust TTLs based on data change frequency
4. **Regional Caching**: Multi-region cache replication for global performance
## Related Documentation
- <mention-page url="...">System Architecture Overview</mention-page>
- <mention-page url="...">Redis Implementation Guide</mention-page>
- <mention-page url="...">API Caching Decision Record</mention-page>
- <mention-page url="...">Performance Optimization - Q3 2024</mention-page>
## Appendix: Configuration Examples
### Redis Configuration
```yaml
maxmemory: 8gb
maxmemory-policy: allkeys-lru
tcp-keepalive: 60Common Cache Operations
# Set with TTL
cache.set(key, value, ttl=300)
# Get with fallback
value = cache.get(key) or fetch_from_db(key)
# Invalidate pattern
cache.delete_pattern("api:v1:users:*")
## Key Success Factors
1. **Multiple source integration**: Combined architecture docs, implementation guides, and decision records
2. **Technical depth**: Included configuration, code examples, metrics
3. **Decision context**: Explained why choices were made, not just what
4. **Practical focus**: Real performance numbers and known issues
5. **Future-looking**: Noted areas for improvement
6. **Well-cited**: Every major point links back to source material
## Workflow Pattern Demonstrated
This example shows the complete research workflow:
- **Scoped search** (teamspace filter for engineering)
- **Multi-page synthesis** (4 different sources)
- **Technical template** (architecture-focused format)
- **Proper placement** (under engineering docs)
- **Comprehensive citations** (links to all sources)
Requirements and compatibility
Written for: OpenAI Codex
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Notion Labs, Inc
- Publisher
- OpenAI (Official)
- Distributed by
- OpenAI
- Source
- openai/skills · skills/.curated/notion-research-documentation · commit 49f948f
- Licence
- MIT License (redistribution allowed)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Notion Labs, Inc or OpenAI.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download notion-research-documentation.zip