PlanOpticon

planopticon / docs / use-cases.md
Source Rendered
Blame History Raw 343 lines
1
# Use Cases
2
3
PlanOpticon is built for anyone who needs to turn unstructured content — recordings, documents, notes, web pages — into structured, searchable, actionable knowledge. Here are the most common ways people use it.
4
5
---
6
7
## Meeting notes and follow-ups
8
9
**Problem:** You have hours of meeting recordings but no time to rewatch them. Action items get lost, decisions are forgotten, and new team members have no way to catch up.
10
11
**Solution:** Point PlanOpticon at your recordings and get structured transcripts, action items with assignees and deadlines, key decisions, and a knowledge graph linking people to topics.
12
13
```bash
14
# Analyze a single meeting recording
15
planopticon analyze -i standup-2026-03-07.mp4 -o ./meetings/march-7
16
17
# Process a month of recordings at once
18
planopticon batch -i ./recordings/march -o ./meetings --title "March 2026 Meetings"
19
20
# Query what was decided
21
planopticon query "What decisions were made about the API redesign?"
22
23
# Find all action items assigned to Alice
24
planopticon query "relationships --source Alice"
25
```
26
27
**What you get:**
28
29
- Full transcript with timestamps and speaker segments
30
- Action items extracted with assignees, deadlines, and context
31
- Key points and decisions highlighted
32
- Knowledge graph connecting people, topics, technologies, and decisions
33
- Markdown report you can share with the team
34
35
**Next steps:** Export to your team's wiki or note system:
36
37
```bash
38
# Push to GitHub wiki
39
planopticon wiki generate --input ./meetings --output ./wiki
40
planopticon wiki push --input ./wiki --target "github://your-org/your-repo"
41
42
# Export to Obsidian for personal knowledge management
43
planopticon export obsidian --input ./meetings --output ~/Obsidian/Meetings
44
```
45
46
---
47
48
## Research processing
49
50
**Problem:** You're researching a topic across YouTube talks, arXiv papers, blog posts, and podcasts. Information is scattered and hard to cross-reference.
51
52
**Solution:** Ingest everything into a single knowledge graph, then query across all sources.
53
54
```bash
55
# Ingest a YouTube conference talk
56
planopticon ingest "https://youtube.com/watch?v=..." --output ./research
57
58
# Ingest arXiv papers
59
planopticon ingest "https://arxiv.org/abs/2401.12345" --output ./research
60
61
# Ingest blog posts and documentation
62
planopticon ingest "https://example.com/blog/post" --output ./research
63
64
# Ingest local PDF papers
65
planopticon ingest ./papers/ --output ./research --recursive
66
67
# Now query across everything
68
planopticon query "What approaches to vector search were discussed?"
69
planopticon query "entities --type technology"
70
planopticon query "neighbors TransformerArchitecture"
71
```
72
73
**What you get:**
74
75
- A unified knowledge graph merging entities across all sources
76
- Cross-references showing where the same concept appears in different sources
77
- Searchable entity index by type (people, technologies, concepts, papers)
78
- Relationship maps showing how ideas connect
79
80
**Go deeper with the companion:**
81
82
```bash
83
planopticon companion --kb ./research
84
```
85
86
```
87
planopticon> What are the main approaches to retrieval-augmented generation?
88
planopticon> /entities --type technology
89
planopticon> /neighbors RAG
90
planopticon> /export obsidian
91
```
92
93
---
94
95
## Knowledge gathering across platforms
96
97
**Problem:** Your team's knowledge is spread across Google Docs, Notion, Obsidian, GitHub wikis, and Apple Notes. There's no single place to search everything.
98
99
**Solution:** Pull from all sources into one knowledge graph.
100
101
```bash
102
# Authenticate with your platforms
103
planopticon auth google
104
planopticon auth notion
105
planopticon auth github
106
107
# Ingest from Google Workspace
108
planopticon gws ingest --folder-id abc123 --output ./kb --recursive
109
110
# Ingest from Notion
111
planopticon ingest --source notion --output ./kb
112
113
# Ingest from an Obsidian vault
114
planopticon ingest ~/Obsidian/WorkVault --output ./kb --recursive
115
116
# Ingest from GitHub wikis and READMEs
117
planopticon ingest "github://your-org/project-a" --output ./kb
118
planopticon ingest "github://your-org/project-b" --output ./kb
119
120
# Query the unified knowledge base
121
planopticon query stats
122
planopticon query "entities --type person"
123
planopticon query "What do we know about the authentication system?"
124
```
125
126
**What you get:**
127
128
- Merged knowledge graph with provenance tracking (you can see which source each entity came from)
129
- Deduplicated entities across platforms (same concept mentioned in Notion and Google Docs gets merged)
130
- Full-text search across all ingested content
131
- Relationship maps showing how concepts connect across your organization's documents
132
133
---
134
135
## Team onboarding
136
137
**Problem:** New team members spend weeks reading docs, watching recorded meetings, and asking questions to get up to speed.
138
139
**Solution:** Build a knowledge base from existing content and let new people explore it conversationally.
140
141
```bash
142
# Build the knowledge base from everything
143
planopticon batch -i ./recordings/onboarding -o ./kb --title "Team Onboarding"
144
planopticon ingest ./docs/ --output ./kb --recursive
145
planopticon ingest ./architecture-decisions/ --output ./kb --recursive
146
147
# New team member launches the companion
148
planopticon companion --kb ./kb
149
```
150
151
```
152
planopticon> What is the overall architecture of the system?
153
planopticon> Who are the key people on the team?
154
planopticon> /entities --type technology
155
planopticon> What was the rationale for choosing PostgreSQL over MongoDB?
156
planopticon> /neighbors AuthenticationService
157
planopticon> What are the main open issues or risks?
158
```
159
160
**What you get:**
161
162
- Interactive Q&A over the entire team knowledge base
163
- Entity exploration — browse people, technologies, services, decisions
164
- Relationship navigation — "show me everything connected to the payment system"
165
- No need to rewatch hours of recordings
166
167
---
168
169
## Data collection and synthesis
170
171
**Problem:** You need to collect and synthesize information from many sources — customer interviews, competitor analysis, market research — into a coherent picture.
172
173
**Solution:** Batch process recordings and documents, then use the planning agent to generate synthesis artifacts.
174
175
```bash
176
# Process customer interview recordings
177
planopticon batch -i ./interviews -o ./research --title "Customer Interviews Q1"
178
179
# Ingest competitor documentation
180
planopticon ingest ./competitor-analysis/ --output ./research --recursive
181
182
# Ingest market research PDFs
183
planopticon ingest ./market-reports/ --output ./research --recursive
184
185
# Use the planning agent to synthesize
186
planopticon agent --kb ./research --interactive
187
```
188
189
```
190
planopticon> Generate a summary of common customer pain points
191
planopticon> /plan
192
planopticon> /tasks
193
planopticon> /export markdown
194
```
195
196
**What you get:**
197
198
- Merged knowledge graph across all interviews and documents
199
- Cross-referenced entities showing which customers mentioned which features
200
- Agent-generated project plans, PRDs, and task breakdowns based on the data
201
- Exportable artifacts for sharing with stakeholders
202
203
---
204
205
## Content creation from video
206
207
**Problem:** You have video content (lectures, tutorials, webinars) that you want to turn into written documentation, blog posts, or course materials.
208
209
**Solution:** Extract structured knowledge and export it in your preferred format.
210
211
```bash
212
# Analyze the video
213
planopticon analyze -i webinar-recording.mp4 -o ./content
214
215
# Generate multiple document types (no LLM needed for these)
216
planopticon export markdown --input ./content --output ./docs
217
218
# Export to Obsidian for further editing
219
planopticon export obsidian --input ./content --output ~/Obsidian/Content
220
```
221
222
**What you get for each video:**
223
224
- Full transcript (JSON, plain text, SRT subtitles)
225
- Extracted diagrams reproduced as Mermaid/SVG/PNG
226
- Charts reproduced with data tables
227
- Knowledge graph of concepts and relationships
228
- 7 types of markdown documents: summary, meeting notes, glossary, relationship map, status report, entity index, CSV data
229
230
---
231
232
## Decision tracking over time
233
234
**Problem:** Important decisions are made in meetings but never formally recorded. Months later, nobody remembers why a choice was made.
235
236
**Solution:** Process meeting recordings continuously and query the growing knowledge graph for decisions and their context.
237
238
```bash
239
# Process each week's recordings
240
planopticon batch -i ./recordings/week-12 -o ./decisions --title "Week 12"
241
242
# The knowledge graph grows over time — entities merge across weeks
243
planopticon query "entities --type goal"
244
planopticon query "entities --type risk"
245
planopticon query "entities --type milestone"
246
247
# Find decisions about a specific topic
248
planopticon query "What was decided about the database migration?"
249
250
# Track risks over time
251
planopticon query "relationships --type risk"
252
```
253
254
The planning taxonomy automatically classifies entities as goals, requirements, risks, tasks, and milestones — giving you a structured view of project evolution over time.
255
256
---
257
258
## Zoom / Teams / Meet integration
259
260
**Problem:** Meeting recordings are sitting in Zoom/Teams/Meet cloud storage. You want to process them without manually downloading each one.
261
262
**Solution:** Authenticate once, list recordings, and process them directly.
263
264
```bash
265
# Authenticate with your meeting platform
266
planopticon auth zoom
267
# or: planopticon auth microsoft
268
# or: planopticon auth google
269
270
# List recent recordings
271
planopticon recordings zoom-list
272
planopticon recordings teams-list --from 2026-01-01
273
planopticon recordings meet-list --limit 20
274
275
# Process recordings (download + analyze)
276
planopticon analyze -i "zoom://recording-id" -o ./output
277
```
278
279
**Setup requirements:**
280
281
| Platform | What you need |
282
|----------|--------------|
283
| Zoom | `ZOOM_CLIENT_ID` + `ZOOM_CLIENT_SECRET` (create an OAuth app at marketplace.zoom.us) |
284
| Teams | `MICROSOFT_CLIENT_ID` + `MICROSOFT_CLIENT_SECRET` (register an Azure AD app) |
285
| Meet | `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` (create OAuth credentials in Google Cloud Console) |
286
287
See the [Authentication guide](guide/authentication.md) for detailed setup instructions.
288
289
---
290
291
## Fully offline processing
292
293
**Problem:** You're working with sensitive content that can't leave your network, or you simply don't want to pay for API calls.
294
295
**Solution:** Use Ollama for local AI processing with no external API calls.
296
297
```bash
298
# Install Ollama and pull models
299
ollama pull llama3.2 # Chat/analysis
300
ollama pull llava # Vision (diagram detection)
301
302
# Install local Whisper for transcription
303
pip install planopticon[gpu]
304
305
# Process entirely offline
306
planopticon analyze -i sensitive-meeting.mp4 -o ./output --provider ollama
307
```
308
309
PlanOpticon auto-detects Ollama when it's running. If no cloud API keys are configured, it uses Ollama automatically. Pair with local Whisper transcription for a fully air-gapped pipeline.
310
311
---
312
313
## Competitive research
314
315
**Problem:** You want to systematically analyze competitor content — conference talks, documentation, blog posts — and identify patterns.
316
317
**Solution:** Ingest competitor content from multiple sources and query for patterns.
318
319
```bash
320
# Ingest competitor conference talks from YouTube
321
planopticon ingest "https://youtube.com/watch?v=competitor-talk-1" --output ./competitive
322
planopticon ingest "https://youtube.com/watch?v=competitor-talk-2" --output ./competitive
323
324
# Ingest their documentation
325
planopticon ingest "https://competitor.com/docs" --output ./competitive
326
327
# Ingest their GitHub repos
328
planopticon auth github
329
planopticon ingest "github://competitor/main-product" --output ./competitive
330
331
# Analyze patterns
332
planopticon query "entities --type technology"
333
planopticon query "What technologies are competitors investing in?"
334
planopticon companion --kb ./competitive
335
```
336
337
```
338
planopticon> What are the common architectural patterns across competitors?
339
planopticon> /entities --type technology
340
planopticon> Which technologies appear most frequently?
341
planopticon> /export markdown
342
```
343

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button