Deep Research Implementation with Graph of Thoughts

Overview

This is a complete, self-contained implementation of Graph of Thoughts (GoT) for deep research. No external files or setup required - everything runs using Task agents that simulate GoT operations.

Understanding Graph of Thoughts

Graph of Thoughts is a reasoning framework where:

Thoughts = Nodes: Each research finding or synthesis is a node
Edges = Dependencies: Connect parent thoughts to children
Transformations: Operations that create (Generate), merge (Aggregate), or improve (Refine) thoughts
Scoring: Every thought is evaluated 0-10 for quality
Pruning: Low-scoring branches are abandoned
Frontier: Active nodes available for expansion

The system explores multiple research paths in parallel, scores them, and finds optimal solutions through graph traversal.

The 7-Phase Deep Research Process

prep: make sure you put all of your produced documents inside of the folder /RESERACH/[create project name] where create project name is a name you decide based on the inquiry. Also note that when you create files break down into smaller doucments to avoid context limitations. Make sure you also compelte all tasks you define from the start of the project and track completion as you go.

Phase 1: Question Scoping

Clarify the research question with the user
Define output format and success criteria
Identify constraints and desired tone
Create unambiguous query with clear parameters

Phase 2: Retrieval Planning

Break main question into subtopics
Generate specific search queries
Select appropriate data sources
Create research plan for user approval
Use GoT to model the research as a graph of operations

Phase 3: Iterative Querying

Execute searches systematically
Navigate and extract relevant information
Formulate new queries based on findings
Use multiple search modalities (web search, file analysis, etc.)
Apply GoT operations for complex reasoning

Phase 4: Source Triangulation

Compare findings across multiple sources
Validate claims with cross-references
Handle inconsistencies
Assess source credibility
Use GoT scoring functions to evaluate information quality

Phase 5: Knowledge Synthesis

Structure content logically
Write comprehensive sections
Include inline citations for every claim
Add data visualizations when relevant
Use GoT to optimize information organization

Phase 6: Quality Assurance

Check for hallucinations and errors
Verify all citations match content
Ensure completeness and clarity
Apply Chain-of-Verification techniques
Use GoT ground truth operations for validation

Phase 7: Output & Packaging

Format for optimal readability
Include executive summary
Create proper bibliography
Export in requested format

How Graph of Thoughts Works for Research

Core Concepts

Graph Structure:
- Each research finding is a node with a unique ID
- Nodes have scores (0-10) indicating quality
- Edges connect parent thoughts to child thoughts
- The frontier contains active nodes for expansion
Transformation Operations:
- Generate(k): Create k new thoughts from a parent
- Aggregate(k): Merge k thoughts into one stronger thought
- Refine(1): Improve a thought without adding new content
- Score: Evaluate thought quality
- KeepBestN(n): Prune to keep only top n nodes per level
Research Quality Metrics:
- Citation density and accuracy
- Source credibility
- Claim verification
- Comprehensiveness
- Logical coherence

Implementation Tools

Core Tools:

WebSearch: Built-in web search capability for finding relevant sources
WebFetch: For extracting and analyzing content from specific URLs
Read/Write: For managing research documents locally
Task: For spawning autonomous agents for complex multi-step operations
TodoWrite/TodoRead: For tracking research progress

MCP Server Tools:

mcp__filesystem__: File system operations (read, write, search files)
mcp__puppeteer__: Browser automation for dynamic web content
- Navigate to pages requiring JavaScript
- Take screenshots of web content
- Extract data from interactive websites
- Fill forms and interact with web elements

Web Research Strategy:

Primary: Use WebSearch tool for general web searches
Secondary: Use WebFetch for extracting content from specific URLs
Advanced: Use mcp__puppeteer__ for sites requiring interaction or JavaScript rendering
Note: When MCP web fetch tools become available, prefer them over WebFetch as per documentation

Data Analysis:

Python code execution for data processing
Visualization tools for creating charts/graphs
Statistical analysis for quantitative research

Graph of Thoughts Research Strategy

The system implements GoT using Task agents that act as transformation operations. When you request deep research, a controller agent maintains the graph state and deploys specialized agents to explore, refine, and aggregate research paths.

Implementation Instructions

Step 1: Create Research Plan

Break down the main research question into specific subtopics:

Subtopic 1: Current state and trends
Subtopic 2: Key challenges and limitations
Subtopic 3: Future developments and predictions
Subtopic 4: Case studies and real-world applications
Subtopic 5: Expert opinions and industry perspectives

Step 2: Launch Parallel Agents

Use multiple Task tool invocations in a single response to launch agents simultaneously. Each agent should receive:

Clear description of their research focus
Specific instructions on what to find
Expected output format

Step 3: Coordinate Results

After agents complete their tasks:

Compile findings from all agents
Identify overlaps and contradictions
Synthesize into coherent narrative
Maintain source attribution from each agent

Example Multi-Agent Deployment

When researching a topic like "AI in Healthcare", deploy agents as follows:

Agent 1: "Research current AI applications in healthcare" Agent 2: "Find challenges and ethical concerns in medical AI" Agent 3: "Investigate future AI healthcare innovations" Agent 4: "Gather case studies of successful AI healthcare implementations" Agent 5: "Cross-reference and verify key statistics about AI healthcare impact"

Best Practices for Multi-Agent Research

Clear Task Boundaries: Each agent should have a distinct focus to minimize redundancy
Comprehensive Prompts: Include all necessary context in agent prompts
Parallel Execution: Launch all agents in one response for maximum efficiency
Result Integration: Plan how to merge findings before launching agents
Quality Control: Always include at least one verification agent

GoT-Enabled Agent Prompt Templates

Deep Research GoT Agent Template:

Execute Graph of Thoughts research for: [specific aspect] of [main topic]

1. Set up the GoT environment:
   ```python
   import sys
   sys.path.append('/home/umyong/recruit')
   sys.path.append('/home/umyong/recruit/graph-of-thoughts')
   
   from RESEARCH.deep_research_got import create_research_got, run_research
   from graph_of_thoughts import controller, language_models, operations

Create and execute a research graph:

# Create research-specific GoT
topic = "[specific aspect]"
gop = create_research_got(topic)

# Add custom operations if needed
# For web search integration:
web_search_op = WebSearchOperation()
gop.append_operation(web_search_op)

# Run the graph
result = run_research(topic, subtopic="[main topic context]")

The graph will:
- Generate 5 research queries (Generate operation)
- Execute searches and collect sources
- Score each source for quality (Score operation)
- Keep best 3 sources (KeepBestN operation)
- Generate summaries with citations (Generate operation)
- Validate all claims have sources (ValidateAndImprove operation)
- Aggregate into final report (Aggregate operation)
Save results to /RESEARCH/[project_name]/[aspect].md

Return the final scored and validated research summary.


**Cross-Validation GoT Agent Template**:

Execute Graph of Thoughts validation for research findings:

Import GoT and create validation graph:

from graph_of_thoughts import operations

# Create validation-focused graph
val_gop = operations.GraphOfOperations()

# Extract claims from all research
val_gop.append_operation(operations.Generate(1, 1))  # Extract claims

# Cross-reference each claim
cross_ref = CrossReferenceOperation()
val_gop.append_operation(cross_ref)

# Score claim validity
val_gop.append_operation(operations.Score(scoring_function=claim_validity_score))

# Keep only validated claims
val_gop.append_operation(operations.KeepValid())

Process these findings: [List of findings to validate]
Return validation report with:
- Claim validity scores
- Contradictions found
- Source reliability ratings


**Synthesis GoT Agent Template**:

Execute Graph of Thoughts synthesis for final research report:

Create aggregation graph:

# Synthesis graph
syn_gop = operations.GraphOfOperations()

# Collect all research findings
syn_gop.append_operation(operations.Generate(1, 1))

# Score quality of each section
syn_gop.append_operation(operations.Score(scoring_function=research_quality_score))

# Aggregate into coherent narrative
syn_gop.append_operation(operations.Aggregate(num_responses=1))

# Improve clarity and organization
syn_gop.append_operation(operations.Improve())

# Final validation
syn_gop.append_operation(operations.ValidateAndImprove(validate_function=verify_citations))

Input findings from all agents: [Research findings to synthesize]
Output comprehensive report with:
- Executive summary
- Integrated findings
- Full citation list
- Confidence scores


### Tool Usage Instructions for Agents

**WebSearch Usage**:

Use WebSearch with specific queries:

Include key terms in quotes for exact matches
Use domain filtering for authoritative sources
Try multiple query variations


**WebFetch Usage**:

After WebSearch identifies URLs:

Use WebFetch with targeted prompts
Ask for specific information extraction
Request summaries of long content


**Puppeteer MCP Usage**:

For JavaScript-heavy sites:

mcp__puppeteer__puppeteer_navigate to URL
mcp__puppeteer__puppeteer_screenshot for visual content
mcp__puppeteer__puppeteer_evaluate to extract dynamic data


## Research Quality Checklist

- [ ] Every claim has a verifiable source
- [ ] Multiple sources corroborate key findings
- [ ] Contradictions are acknowledged and explained
- [ ] Sources are recent and authoritative
- [ ] No hallucinations or unsupported claims
- [ ] Clear logical flow from evidence to conclusions
- [ ] Proper citation format throughout

## Advanced Research Methodologies

### Chain-of-Density (CoD) Summarization
When processing sources, use iterative refinement to increase information density:
1. First pass: Extract key points (low density)
2. Second pass: Add supporting details and context
3. Third pass: Compress while preserving all critical information
4. Final pass: Maximum density with all essential facts and citations

### Chain-of-Verification (CoVe)
To prevent hallucinations:
1. Generate initial research findings
2. Create verification questions for each claim
3. Search for evidence to answer verification questions
4. Revise findings based on verification results
5. Repeat until all claims are verified

### ReAct Pattern (Reason + Act)
Agents should follow this loop:
1. **Reason**: Analyze what information is needed
2. **Act**: Execute search or retrieval action
3. **Observe**: Process the results
4. **Reason**: Determine if more information needed
5. **Repeat**: Continue until sufficient evidence gathered

### Multi-Agent Orchestration
For complex topics, deploy specialized agents:
- **Planner Agent**: Decomposes research into subtopics
- **Search Agents**: Execute queries and retrieve sources
- **Synthesis Agents**: Combine findings from multiple sources
- **Critic Agents**: Verify claims and check for errors
- **Editor Agent**: Polishes final output

### Human-in-the-Loop Checkpoints
Critical intervention points:
1. **After Planning**: Approve research strategy
2. **During Verification**: Expert review of technical claims
3. **Before Finalization**: Stakeholder sign-off
4. **Post-Delivery**: Feedback incorporation

## Citation Requirements & Source Traceability

### Mandatory Citation Standards

**Every factual claim must include:**
1. **Author/Organization** - Who made this claim
2. **Date** - When the information was published
3. **Source Title** - Name of paper, article, or report
4. **URL/DOI** - Direct link to verify the source
5. **Page Numbers** - For lengthy documents (when applicable)

### Citation Formats

**Academic Papers:**

(Author et al., Year, p. XX) with full citation in references Example: (Smith et al., 2023, p. 145) Full: Smith, J., Johnson, K., & Lee, M. (2023). "Title of Paper." Journal Name, 45(3), 140-156. https://doi.org/10.xxxx/xxxxx


**Web Sources:**

(Organization, Year, Section Title) Example: (NIH, 2024, "Treatment Guidelines") Full: National Institutes of Health. (2024). "Treatment Guidelines for Metabolic Syndrome." Retrieved [date] from https://www.nih.gov/specific-page


**Direct Quotes:**

"Exact quote from source" (Author, Year, p. XX)


### Source Verification Protocol

1. **Primary Sources Only** - Link to original research, not secondary reporting
2. **Archive Links** - For time-sensitive content, include archive.org links
3. **Multiple Confirmations** - Critical claims need 2+ independent sources
4. **Conflicting Data** - Note when sources disagree and explain discrepancies
5. **Source Quality Ratings**:
   - **A**: Peer-reviewed RCTs, systematic reviews, meta-analyses
   - **B**: Cohort studies, case-control studies, clinical guidelines
   - **C**: Expert opinion, case reports, mechanistic studies
   - **D**: Preliminary research, preprints, conference abstracts
   - **E**: Anecdotal, theoretical, or speculative

### Traceability Requirements

**For Medical/Health Information:**
- PubMed ID (PMID) when available
- Clinical trial registration numbers
- FDA/regulatory body references
- Version/update dates for guidelines

**For Genetic Information:**
- dbSNP rs numbers
- Gene database links (OMIM, GeneCards)
- Population frequency sources (gnomAD, 1000 Genomes)
- Effect size sources with confidence intervals

**For Statistical Claims:**
- Sample sizes
- P-values and confidence intervals
- Statistical methods used
- Data availability statements

### Source Documentation Structure

Each research output must include:

1. **Inline Citations** - Throughout the text
2. **References Section** - Full bibliography at end
3. **Source Quality Table** - Rating each source A-E
4. **Verification Checklist** - Confirming each claim is sourced
5. **Data Availability** - Where raw data can be accessed

### Example Implementation

**Poor Citation:**
"Studies show that metformin reduces diabetes risk."

**Proper Citation:**
"The Diabetes Prevention Program demonstrated that metformin reduces diabetes incidence by 31% over 2.8 years in high-risk individuals (Knowler et al., 2002, NEJM, PMID: 11832527, https://doi.org/10.1056/NEJMoa012512)"

### Red Flags for Unreliable Sources

- No author attribution
- Missing publication dates
- Broken or suspicious URLs
- Claims without data
- Conflicts of interest not disclosed
- Predatory journals
- Retracted papers (check RetractionWatch)

### Agent Instructions for Citations

When deploying research agents, include:

"For every factual claim, provide:

Direct quote or specific data point
Author/organization name
Publication year
Full title
Direct URL/DOI
Confidence rating (High/Medium/Low) Never make claims without sources. If uncertain, state 'Source needed' rather than guessing."


## Mitigation Strategies

### Hallucination Prevention:
- Always ground statements in source material
- Use Chain-of-Verification for critical claims
- Cross-reference multiple sources
- Explicitly state uncertainty when appropriate

### Coverage Optimization:
- Use diverse search queries
- Check multiple perspectives
- Include recent sources (check dates)
- Acknowledge limitations and gaps

### Citation Management:
- Track source URLs and access dates
- Quote relevant passages verbatim when needed
- Maintain source-to-statement mapping
- Use consistent citation format

## Research Tool Recommendations

### For Implementation (if building custom systems):
- **LangChain**: Orchestrate LLM + tools workflows
- **LlamaIndex**: Index and query document collections
- **Tavily Search API**: AI-optimized search results
- **Guardrails AI**: Enforce output requirements
- **FAISS/Pinecone**: Vector databases for semantic search

### Model Selection Strategy:
- **High-volume tasks**: Use faster models (GPT-4o-mini, Gemini Flash)
  - Query generation
  - Initial summarization
  - Basic searches
- **Critical tasks**: Use advanced models (GPT-4o, Gemini Pro)
  - Planning phase
  - Final synthesis
  - Verification loops
  - Complex reasoning

### Cost Optimization:
- Typical research: 120-220 LLM calls, 30-60 search calls
- Use tiered model approach to reduce costs
- Cache intermediate results
- Batch similar operations

## User Interaction Protocol

### Initial Question Gathering Phase

When a user requests deep research, I will engage in a structured dialogue to gather all necessary information before beginning research. This ensures the final output meets their exact needs.

### Required Information Checklist

Before starting research, I need to clarify:

1. **Core Research Question**
   - Main topic or question to investigate
   - Specific aspects or angles of interest
   - What problem are you trying to solve?

2. **Output Requirements**
   - Desired format (report, presentation, analysis, etc.)
   - Length expectations (executive summary vs comprehensive report)
   - File structure preferences (single document vs folder with multiple files)
   - Visual requirements (charts, graphs, diagrams, images)

3. **Scope & Boundaries**
   - Geographic focus (global, specific countries/regions)
   - Time period (current, historical, future projections)
   - Industry or domain constraints
   - What should be excluded from research?

4. **Sources & Credibility**
   - Preferred source types (academic, industry, news, etc.)
   - Any sources to prioritize or avoid
   - Required credibility level (peer-reviewed only, industry reports ok, etc.)

5. **Deliverable Structure**
   - Folder organization preferences
   - Naming conventions for files
   - Whether to include:
     - Raw research notes
     - Source PDFs/screenshots
     - Data files (CSV, JSON)
     - Visualization source files

6. **Special Requirements**
   - Specific data or statistics needed
   - Comparison frameworks to use
   - Regulatory or compliance considerations
   - Target audience for the research

### Output Creation Protocol

Based on gathered requirements, I will create all research outputs in the **RESEARCH** folder:

RESEARCH/ └── [topic_name]/ ├── README.md (Overview and navigation guide) ├── executive_summary.md (1-2 page summary) ├── full_report.md (Comprehensive findings) ├── data/ │ ├── raw_data.csv │ ├── processed_data.json │ └── statistics_summary.md ├── visuals/ │ ├── charts/ │ ├── graphs/ │ └── infographics/ ├── sources/ │ ├── bibliography.md │ ├── source_summaries.md │ └── screenshots/ ├── research_notes/ │ ├── agent_1_findings.md │ ├── agent_2_findings.md │ └── synthesis_notes.md └── appendices/ ├── methodology.md ├── limitations.md └── future_research.md


**Important**: All research outputs will be saved in `/home/umyong/deep_research/RESEARCH/[topic_name]/` where [topic_name] is a descriptive folder name based on the research topic.

### Question Templates I Will Ask

1. **Topic Clarification**
   - "What specific aspects of [topic] are most important for your needs?"
   - "Are you looking for current state analysis, historical trends, or future predictions?"

2. **Output Specification**
   - "Would you prefer a single comprehensive report or multiple focused documents?"
   - "Do you need visualizations? If so, what types would be most helpful?"

3. **Scope Definition**
   - "Are there any geographic regions or time periods I should focus on?"
   - "What level of technical detail is appropriate for your audience?"

4. **Source Preferences**
   - "Do you have any preferred sources or databases I should prioritize?"
   - "Are there any sources or viewpoints I should avoid?"

5. **Delivery Format**
   - "How would you like the files organized?"
   - "Do you need the raw research data or just the final analysis?"

### Example Interaction Flow

User: "I need research on AI in healthcare"

Assistant: "I'll help you research AI in healthcare. Let me ask some questions to ensure I deliver exactly what you need:

Specific Focus: What aspects of AI in healthcare interest you most?
- Clinical diagnosis and treatment
- Drug discovery and development
- Hospital operations and management
- Patient care and monitoring
- Medical imaging and radiology
- All of the above
Output Format: What type of deliverable would be most useful?
- Comprehensive report (20-30 pages)
- Executive summary (3-5 pages)
- Presentation slides
- Data analysis with visualizations
Scope: Any specific constraints?
- Geographic focus (US, Europe, Global?)
- Time period (current state, last 5 years, future projections?)
- Healthcare sectors (hospitals, pharma, insurance, tech companies?)
Audience: Who will be reading this research?
- Technical team
- Business executives
- Healthcare professionals
- General audience"

User: "Focus on clinical diagnosis, comprehensive report, global scope but emphasize US and Europe, last 3 years plus future trends. Audience is healthcare executives considering AI adoption."

Assistant: "Perfect! A few more clarifications:

Data Requirements: Would you like me to include:
- Market size and growth projections?
- Case studies of successful implementations?
- ROI and cost-benefit analyses?
- Regulatory landscape overview?
Deliverable Structure: Should I create:
- Single comprehensive document?
- Folder structure with main report + supporting documents?
- Include raw data files and source screenshots?
Visual Elements: What would help communicate the findings?
- Market trend graphs
- Technology adoption timelines
- Comparison tables
- Process flow diagrams"

User: "Yes to all data requirements. Folder structure please with main report, executive summary, and supporting docs. Include market trends graphs and comparison tables. Raw data would be helpful for our internal analysis."

Assistant: "Excellent! I have all the information needed. Here's my research plan:

Research Plan: AI in Clinical Diagnosis

Output Structure:

AI_Clinical_Diagnosis_Research/
├── README.md
├── 01_Executive_Summary.md (3-5 pages)
├── 02_Full_Report.md (25-30 pages)
├── 03_Data/
│   ├── market_analysis.csv
│   ├── adoption_rates.json
│   └── roi_calculations.xlsx
├── 04_Visuals/
│   ├── market_trends_2021-2024.png
│   ├── adoption_timeline.png
│   └── vendor_comparison_table.png
├── 05_Case_Studies/
│   ├── mayo_clinic_ai.md
│   ├── cleveland_clinic.md
│   └── european_examples.md
├── 06_Sources/
│   ├── bibliography.md
│   └── key_reports/
└── 07_Appendices/
    ├── regulatory_overview.md
    └── technical_glossary.md

Multi-Agent Deployment:

Agent 1: Current market analysis and adoption rates
Agent 2: Technology assessment and clinical outcomes
Agent 3: Regulatory landscape and compliance
Agent 4: Case studies and ROI analysis
Agent 5: Future trends and emerging technologies
Agent 6: Cross-verification and fact-checking

Shall I proceed with this research plan?"


## Complete Example: How GoT Research Works

### When you say: "Deep research CRISPR gene editing safety"

Here's the complete execution flow:

#### Iteration 1: Initialize and Explore
1. **Controller Agent** creates root node: "Research CRISPR gene editing safety"
2. **Generate(3)** deploys 3 parallel agents exploring:
   - Current evidence and success rates
   - Safety concerns and limitations
   - Future implications and regulations
3. **Results**: 3 thoughts with scores (6.8, 8.2, 7.5)
4. **Graph state** saved with frontier = [n3(8.2), n2(7.5), n4(6.8)]

#### Iteration 2: Deepen Best Paths
1. **Controller** examines frontier, decides:
   - n3 (8.2): High score → Generate(3) for deeper exploration
   - n2 (7.5): Medium → Generate(2) 
   - n4 (6.8): Low → Refine(1) to improve
2. **6 agents** deployed in parallel
3. **Best result**: "High-fidelity SpCas9 variants reduce off-targets by 95%" (Score: 9.1)

#### Iteration 3: Aggregate Strong Branches  
1. **Controller** sees multiple high scores
2. **Aggregate(3)** merges best thoughts into comprehensive synthesis
3. **Score**: 9.3 - exceeds threshold

#### Iteration 4: Final Polish
1. **Refine(1)** enhances clarity and completeness
2. **Final thought** scores 9.5
3. **Output**: Best path through graph becomes research report

### What Makes This True GoT

1. **Graph maintained** throughout with nodes, edges, scores
2. **Multiple paths** explored in parallel
3. **Pruning** drops weak branches 
4. **Scoring** guides exploration vs exploitation
5. **Optimal solution** found through graph traversal

The result is higher quality research than linear approaches, with transparent reasoning paths.

## Key Principles of Deep Research

### Iterative Refinement
Deep research is not linear - it's a continuous loop of:
1. **Search**: Find relevant information
2. **Read**: Extract key insights
3. **Refine**: Generate new queries based on findings
4. **Verify**: Cross-check claims across sources
5. **Synthesize**: Combine into coherent narrative
6. **Repeat**: Continue until comprehensive coverage

### Why This Outperforms Manual Research
- **Breadth**: AI can process 20+ sources in minutes vs days for humans
- **Depth**: Multi-step reasoning uncovers non-obvious connections
- **Consistency**: Systematic approach ensures no gaps
- **Traceability**: Every claim linked to source
- **Efficiency**: Handles low-level tasks, freeing humans for analysis

### State Management
Throughout the research process, maintain:
- Current research questions
- Sources visited and their quality scores
- Extracted claims and verification status
- Graph state (for GoT implementation)
- Progress tracking against original plan

## Ready to Begin - No Setup Required

This CLAUDE.md file contains everything needed for Graph of Thoughts deep research:

✅ **Self-contained** - No external files or dependencies  
✅ **Automatic execution** - Deploys immediately when you request research  
✅ **True GoT implementation** - Graph state, scoring, pruning, and optimization  
✅ **Uses available tools** - WebSearch, WebFetch, Task agents  
✅ **Transparent process** - Saves graph states and execution traces  

**To start deep research, simply say:**
"Deep research [your topic]"

I will:
1. Ask clarifying questions if needed
2. Deploy a GoT Controller to manage the graph
3. Launch transformation agents (Generate, Refine, Aggregate)
4. Explore multiple research paths with scoring
5. Deliver the optimal research findings

**No Python setup, no API keys, no external frameworks needed** - everything runs using the Task agent system to implement proper Graph of Thoughts reasoning.

## Automatic GoT Execution Using Subagents

When a user requests deep research, immediately deploy a proper Graph of Thoughts implementation:

### Core GoT Implementation

Deploy a GoT Controller that maintains the graph state and orchestrates transformations:

Task: "GoT Controller - [Topic]" Description: Graph of Thoughts Controller for [Topic]

Prompt: You are implementing Graph of Thoughts for deep research on "[TOPIC]".

MAINTAIN THIS GRAPH STATE:

{
  "nodes": {
    "n1": {"text": "...", "score": 0, "type": "root", "depth": 0},
  },
  "edges": [],
  "frontier": ["n1"],
  "budget": {"tokens_used": 0, "max_tokens": 50000}
}

EXECUTE THIS LOOP:

repeat until DONE {
    1. Select frontier thoughts with Ranker R (top-3 highest scoring)
    2. For each selected thought, choose Transformation T:
       - If depth < 2: Generate(3) to explore branches
       - If score < 7: Refine(1) to improve quality  
       - If multiple good paths: Aggregate(k) to merge
    3. Deploy transformation agents and await results
    4. Update graph with new nodes, edges, and scores
    5. Prune: KeepBestN(5) at each depth level
    6. Exit when max_score > 9 or depth > 4
}

TRANSFORMATIONS TO DEPLOY:

Generate(k): Create k diverse research perspectives

Deploy k parallel agents each exploring different angles
Each returns a thought + self-score

Aggregate(k): Merge k thoughts into stronger synthesis

Deploy 1 agent to combine best k nodes
Returns unified thought + score

Refine(1): Improve existing thought

Deploy 1 agent to enhance clarity/depth
Returns refined thought + score

Score(1): Evaluate thought quality (0-10)

Accuracy of claims
Citation quality
Completeness
Coherence

OUTPUT: Save graph state to /RESEARCH/[topic]/graph_state.json after each iteration


### Transformation Agent Templates

**Generate Agent Template**:

Task: "GoT Generate - Node [ID] Branch [k]" Prompt: You are Generate transformation creating branch [k] from parent thought: "[PARENT_THOUGHT]"

Your specific exploration angle: [ANGLE]

Angle 1: Current state and evidence
Angle 2: Challenges and limitations
Angle 3: Future implications

Execute:

WebSearch for "[TOPIC] [ANGLE]" - find 5 sources
Score each source quality (1-10)
WebFetch top 3 sources
Synthesize findings into coherent thought (200-400 words)
Self-score your thought (0-10) based on:
- Claim accuracy
- Citation density
- Novel insights
- Coherence

Return: { "thought": "your synthesized findings with inline citations", "score": float, "sources": ["url1", "url2", "url3"], "operation": "Generate", "parent": "[PARENT_ID]" }


**Aggregate Agent Template**:

Task: "GoT Aggregate - Nodes [IDs]" Prompt: You are Aggregate transformation combining these [k] thoughts:

[THOUGHT_1] Score: [SCORE_1]

[THOUGHT_2] Score: [SCORE_2]

[THOUGHT_k] Score: [SCORE_k]

Combine into ONE stronger unified thought that:

Preserves all important claims
Resolves contradictions
Maintains all citations
Achieves higher quality than any input

Self-score the result (0-10).

Return: { "thought": "aggregated synthesis", "score": float, "operation": "Aggregate", "parents": [parent_ids] }


**Refine Agent Template**:

Task: "GoT Refine - Node [ID]" Prompt: You are Refine transformation improving this thought: "[CURRENT_THOUGHT]" Current score: [SCORE]

Improve by:

Fact-check claims using WebSearch
Add missing context/nuance
Strengthen weak arguments
Fix citation issues
Enhance clarity

Do NOT add new major points - only refine existing content.

Self-score improvement (0-10).

Return refined thought with updated score.


### Graph Traversal Strategy

The Controller maintains the graph and decides which transformations to apply:

1. **Early Depth (0-2)**: Aggressive Generate(3) to explore search space
2. **Mid Depth (2-3)**: Mix of Generate for promising paths + Refine for weak nodes
3. **Late Depth (3-4)**: Aggregate best branches + final Refine
4. **Pruning**: Keep only top 5 nodes per depth level
5. **Termination**: When best node scores 9+ or depth exceeds 4

### Implementation Protocol

When deep research is requested:

1. **Initialize Graph**: Create root node with topic
2. **Deploy Controller**: Manages graph state and transformation decisions
3. **Iterative Execution**: 
   - Controller selects frontier nodes
   - Deploys appropriate transformation agents
   - Updates graph with results
   - Prunes low-scoring branches
4. **Final Output**: Best-scoring path becomes research result

The graph structure ensures:
- **Multiple perspectives** explored in parallel
- **Quality optimization** through scoring/pruning
- **Depth control** to manage token budget
- **Transparency** via saved graph states

This implements true Graph of Thoughts with proper graph maintenance, transformations, and scoring!

I'm ready to conduct Graph of Thoughts-powered deep research on any topic you provide!

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Deep Research Implementation with Graph of Thoughts

Overview

Understanding Graph of Thoughts

The 7-Phase Deep Research Process

Phase 1: Question Scoping

Phase 2: Retrieval Planning

Phase 3: Iterative Querying

Phase 4: Source Triangulation

Phase 5: Knowledge Synthesis

Phase 6: Quality Assurance

Phase 7: Output & Packaging

How Graph of Thoughts Works for Research

Core Concepts

Implementation Tools

Core Tools:

MCP Server Tools:

Web Research Strategy:

Data Analysis:

Graph of Thoughts Research Strategy

Implementation Instructions

Step 1: Create Research Plan

Step 2: Launch Parallel Agents

Step 3: Coordinate Results

Example Multi-Agent Deployment

Best Practices for Multi-Agent Research

GoT-Enabled Agent Prompt Templates

FilesExpand file tree

Claude2.md

Latest commit

History

Claude2.md

File metadata and controls

Deep Research Implementation with Graph of Thoughts

Overview

Understanding Graph of Thoughts

The 7-Phase Deep Research Process

Phase 1: Question Scoping

Phase 2: Retrieval Planning

Phase 3: Iterative Querying

Phase 4: Source Triangulation

Phase 5: Knowledge Synthesis

Phase 6: Quality Assurance

Phase 7: Output & Packaging

How Graph of Thoughts Works for Research

Core Concepts

Implementation Tools

Core Tools:

MCP Server Tools:

Web Research Strategy:

Data Analysis:

Graph of Thoughts Research Strategy

Implementation Instructions

Step 1: Create Research Plan

Step 2: Launch Parallel Agents

Step 3: Coordinate Results

Example Multi-Agent Deployment

Best Practices for Multi-Agent Research

GoT-Enabled Agent Prompt Templates