Notion Research Documentation
JetBrainsOfficialCreated by OpenAIDistributed by JetBrains
- 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 agent through searching for relevant pages, fetching content, selecting an appropriate output format, and drafting structured documents such as briefs, summaries, or reports. The workflow emphasizes accuracy by requiring inline citations and direct links back to the original source material, ensuring that all synthesized findings are verifiable and well-organized.
What it does
- Searches and retrieves relevant content across Notion workspaces.
- Synthesizes raw information into structured formats like briefs or reports.
- Provides templates for various documentation needs including comparisons and deep dives.
- Ensures traceability by linking findings to their original source pages.
- Supports the creation of actionable tasks or checklists within the generated documents.
- Includes a setup procedure for connecting the Notion MCP client.
When to use it
- When you need to consolidate information from multiple Notion pages into a single report.
- When performing research that requires verifiable citations from internal documentation.
- When creating executive summaries, competitor analyses, or technical investigations.
- When you need to present findings in a standardized, professional format.
Advantages
- Reduces manual effort in aggregating scattered information.
- Improves documentation quality through standardized templates.
- Increases transparency by maintaining clear links to source data.
- Facilitates better decision-making by organizing findings into clear, actionable insights.
Usage examples
- “Research our recent meeting notes in Notion and create a summary of all action items.”
- The agent searches for relevant meeting pages, extracts action items, and compiles them into a structured summary document with links to the original meeting notes.
- “Compare the two project proposals I have in Notion and create a comparison report.”
- The agent fetches both proposal documents, identifies key tradeoffs, and generates a comparison report using the designated template.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/jetbrains/notion-research-documentation/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 OpenAI
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 AutoGineer983 B
- LICENSE.txt1.0 KiB
- SKILL.md3.4 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
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
- OpenAI
- Publisher
- JetBrains (Official)
- Distributed by
- JetBrains
- Source
- JetBrains/skills · notion-research-documentation · commit 3f53782
- Licence
- MIT License (redistribution allowed)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by OpenAI or JetBrains.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download notion-research-documentation.zip