Automate niche research with Wikipedia + AI agent

What This Agent Does

This powerful automation workflow transforms any topic into a comprehensive, AI-generated history summary and automatically logs it to Google Sheets. Simply provide a topic name, and the agent searches Wikipedia, scrapes the full article content, extracts the history section, and uses GPT-4o-mini to generate an engaging historical narrative. The final summary is then appended to your Google Sheets spreadsheet for easy access and organization.

Key benefits:

• Save hours of research time by automating the entire process from search to summary
• Generate consistent, high-quality historical content using advanced AI
• Build a searchable knowledge base automatically in Google Sheets
• Perfect for content creators, researchers, educators, and historians who need quick access to historical information

Typical use cases: Creating historical content for blog posts, building educational materials, researching company or product histories, compiling historical data for presentations, or maintaining a curated database of historical summaries.

Who Is It For

This workflow is ideal for:

• Content creators and bloggers who need historical context for articles and posts
• Educators and teachers building lesson plans or study materials
• Researchers and students conducting preliminary research on various topics
• Marketing professionals researching brand or industry histories
• Knowledge managers building organizational knowledge bases
• Historians and enthusiasts cataloging historical information systematically

Whether you're producing content at scale or conducting deep research, this agent eliminates the tedious manual work of searching, reading, extracting, and summarizing historical information.

Required Integrations

Wikipedia Scraper

Why it's needed: This integration retrieves the full content of Wikipedia articles, providing the raw material for your historical summaries. Without it, the workflow cannot access the detailed article text needed for AI processing.

Setup steps:

1. Navigate to the Integrations section in your TaskAGI dashboard
2. Search for "Wikipedia Scraper" in the integration marketplace
3. Click Connect or Install to add it to your workspace
4. Most Wikipedia Scraper integrations don't require API keys as they use public data
5. If prompted, configure any rate limiting settings (recommended: 1-2 requests per second)
6. Click Save to complete the integration setup

Configuration in TaskAGI:

• Once installed, the integration will appear in your available nodes
• No additional authentication is typically required
• The integration handles all Wikipedia API interactions automatically

OpenAI

Why it's needed: OpenAI's GPT-4o-mini model powers the intelligent summarization of historical content. This integration transforms raw Wikipedia text into polished, engaging historical narratives tailored to your needs.

Setup steps:

1. Create an OpenAI account at https://platform.openai.com if you don't have one
2. Navigate to API Keys in your OpenAI dashboard
3. Click Create new secret key and give it a descriptive name (e.g., "TaskAGI History Generator")
4. Copy the API key immediately (you won't be able to see it again)
5. In TaskAGI, go to Integrations and find OpenAI
6. Click Connect and paste your API key when prompted
7. Test the connection to ensure it's working properly
8. Click Save to finalize the integration

Important notes:

• OpenAI charges per token used; GPT-4o-mini is cost-effective for this use case
• Monitor your usage in the OpenAI dashboard to track costs
• Set up billing limits in OpenAI to control spending

Google Sheets

Why it's needed: This integration stores your generated historical summaries in an organized, accessible spreadsheet format. It enables automatic logging and creates a searchable database of all your research.

Setup steps:

1. Go to Integrations in TaskAGI and locate Google Sheets
2. Click Connect with Google
3. Select the Google account that has access to your target spreadsheet
4. Grant TaskAGI the necessary permissions (read and write access to sheets)
5. Complete the OAuth authorization flow
6. Verify the connection shows as "Connected" in your integrations list

Preparing your Google Sheet:

1. Create a new Google Sheet or open an existing one
2. Set up column headers in the first row (recommended: Topic, Summary, Timestamp, Source URL)
3. Copy the sheet URL from your browser
4. Keep this URL handy for the configuration steps below

Configuration Steps

Step 1: Set Up the Manual Trigger

The Manual Trigger node initiates your workflow on demand.

1. This node requires no configuration—it's ready to use out of the box
2. You'll click this trigger each time you want to generate a new history summary
3. The trigger captures a timestamp that can be used for logging purposes

Step 2: Configure Set Topic Node

The Set Topic node (core.edit_data) defines what subject you want to research.

1. Click on the Set Topic node to open its configuration panel
2. Create a new data field called topic
3. Set the value to your desired subject (e.g., "Artificial Intelligence", "Roman Empire", "Tesla Motors")
4. Pro tip: You can make this dynamic by connecting it to a form input or external trigger in advanced setups
5. Ensure the output is set to pass the topic variable to the next node

Example configuration:

{
  "topic": "Ancient Egypt"
}

Step 3: Configure Wikipedia Search API

The Wikipedia Search API node (core.http_request) finds the correct Wikipedia article.

1. Set the HTTP Method to GET
2. Configure the URL as: https://en.wikipedia.org/w/api.php
3. Add the following Query Parameters:
   • action: opensearch
   • search: {{topic}} (reference the topic from the previous node)
   • limit: 1
   • format: json
4. Set Headers (if needed):
   • User-Agent: TaskAGI-HistoryBot/1.0
5. Leave authentication empty (Wikipedia API is public)

This node returns search results including the article title and URL.

Step 4: Configure Construct Page URL

The Construct Page URL node (core.function) builds the full Wikipedia article URL.

1. Set the Function Type to JavaScript or Python (depending on your preference)
2. Input the following code:

JavaScript:

const searchResults = input.data;
const pageTitle = searchResults[1][0]; // First result title
const pageUrl = searchResults[3][0]; // First result URL
return { pageUrl, pageTitle };

3. Map the input to receive data from the Wikipedia Search API node
4. This node outputs pageUrl and pageTitle for the next step

Step 5: Configure Wikipedia Scraper

The Wikipedia Scraper node retrieves the complete article content.

1. Select scrapeWikipediaArticles as the action
2. Set the Article URL field to {{pageUrl}} from the previous node
3. Configure Options:
   • Include sections: true (to get structured content)
   • Include references: false (to reduce noise)
   • Format: plain text or markdown (your preference)
4. Set a reasonable timeout (30-60 seconds for longer articles)

The output contains the full article structure with all sections.

Step 6: Configure Extract History Section

The Extract History Section node (core.function) isolates the historical content.

1. Create a new function node
2. Use this code to extract the history section:

JavaScript:

const article = input.articles[0];
const sections = article.sections;

// Find history-related sections
const historySection = sections.find(s => 
  s.title.toLowerCase().includes('history') || 
  s.title.toLowerCase().includes('background')
);

if (historySection) {
  return { historyText: historySection.content };
} else {
  // Fallback to first few paragraphs
  return { historyText: article.content.substring(0, 2000) };
}

3. This ensures you're only sending relevant historical content to the AI

Step 7: Configure Generate History Summary

The Generate History Summary node (openai.createCompletion) creates your polished output.

1. Select GPT-4o-mini as the model (cost-effective and powerful)
2. Configure the System Prompt:

You are the Niche History Generator AI. Return a comprehensive, engaging historical summary based on the provided content. Focus on key events, dates, and developments. Write in a clear, narrative style suitable for general audiences. Aim for 300-500 words.

3. Set the User Prompt to: {{historyText}}
4. Configure Parameters:
   • Temperature: 0.7 (balanced creativity and accuracy)
   • Max tokens: 800 (allows for detailed summaries)
   • Top P: 1.0
5. Enable streaming: false (wait for complete response)

Step 8: Configure Format AI Output

The Format AI Output node (core.function) prepares data for Google Sheets.

1. Create a function to structure the output:

JavaScript:

const summary = input.content;
const topic = input.topic;
const sourceUrl = input.pageUrl;
const timestamp = new Date().toISOString();

return {
  row: [topic, summary, timestamp, sourceUrl]
};

2. This creates an array matching your Google Sheets columns

Step 9: Configure Append to Google Sheets

The Append to Google Sheets node saves your results.

1. Select appendRowFromUrl as the action
2. Paste your Sheet URL: https://docs.google.com/spreadsheets/d/1P0wZ449wVN...
3. Set Row Data to {{row}} from the Format AI Output node
4. Configure Options:
   • Sheet name: Specify the tab name (e.g., "History Summaries")
   • Value input option: USER_ENTERED (preserves formatting)
5. Enable Create sheet if not exists: true (optional safety feature)

Testing Your Agent

Running Your First Test

1. Click the Manual Trigger node to start the workflow
2. Watch the execution flow through each node in real-time
3. TaskAGI will display progress indicators as each step completes
4. The entire process typically takes 15-30 seconds depending on article length

Verification Checklist

After Wikipedia Search API:

• ✓ Verify the search returned a relevant article title
• ✓ Check that the URL looks correct (should be a wikipedia.org link)

After Wikipedia Scraper:

• ✓ Confirm article content was retrieved (check the data preview)
• ✓ Verify sections are properly structured

After Extract History Section:

• ✓ Ensure historical content was found (not empty)
• ✓ Check that the text is relevant to the topic's history

After Generate History Summary:

• ✓ Review the AI-generated summary for quality and accuracy
• ✓ Confirm it's within the expected word count (300-500 words)
• ✓ Verify it reads naturally and includes key historical points

After Append to Google Sheets:

• ✓ Open your Google Sheet and verify the new row was added
• ✓ Check that all columns are populated correctly
• ✓ Confirm the timestamp is accurate

Expected Results

A successful execution should produce:

• A new row in your Google Sheet with topic name, summary, timestamp, and source URL
• A coherent, well-written historical summary of 300-500 words
• Proper formatting with no error messages in any node
• Total execution time under 60 seconds

Troubleshooting

Wikipedia Search Returns No Results

Problem: The search API doesn't find a matching article.

Solutions:

• Check your topic spelling and try alternative phrasings
• Remove special characters or overly specific terms
• Try broader search terms (e.g., "AI" instead of "Artificial Intelligence in Healthcare")
• Verify the Wikipedia Search API node has correct parameters

OpenAI API Errors

Problem: "Authentication failed" or "Insufficient quota" errors.

Solutions:

• Verify your OpenAI API key is correctly entered in integrations
• Check your OpenAI account has available credits
• Ensure you haven't exceeded rate limits (wait a few minutes)
• Confirm your API key has the necessary permissions

Problem: AI summary is too short or off-topic.

Solutions:

• Increase the max_tokens parameter (try 1000-1200)
• Adjust the temperature (lower = more focused, higher = more creative)
• Refine your system prompt to be more specific about requirements
• Verify the history extraction is capturing relevant content

Google Sheets Integration Issues

Problem: "Permission denied" or "Sheet not found" errors.

Solutions:

• Re-authenticate the Google Sheets integration
• Verify the sheet URL is correct and accessible
• Ensure the Google account connected has edit permissions
• Check that the sheet name matches exactly (case-sensitive)
• Make sure the sheet isn't protected or locked

Problem: Data appears in wrong columns.

Solutions:

• Verify your Format AI Output node returns data in the correct order
• Check that your Google Sheet headers match your data structure
• Ensure you're using USER_ENTERED as the value input option

Workflow Execution Hangs

Problem: The workflow stops at a particular node without completing.

Solutions:

• Check timeout settings on HTTP request and scraper nodes
• Verify all required fields are populated with valid data
• Look for circular references in data mapping
• Review execution logs for specific error messages
• Try running the workflow with a simpler topic first

Next Steps

After Successful Setup

Congratulations! Your History Generator agent is now operational. Here's what to do next:

1. Run multiple tests with different topics to build your knowledge base
2. Review and refine your AI prompts based on output quality
3. Organize your Google Sheet with filters, conditional formatting, or additional columns
4. Set up scheduled runs if you want to generate summaries automatically
5. Share your results with team members by sharing the Google Sheet

Optimization Suggestions

Improve AI Output Quality:

• Experiment with different temperature settings (0.5-0.9 range)
• Add specific instructions to your prompt (e.g., "Focus on 20th century developments")
• Increase max tokens for more detailed summaries
• Try GPT-4 for even higher quality (at higher cost)

Enhance Data Collection:

• Add additional columns for categories, tags, or ratings
• Include word count or reading time calculations
• Extract and store key dates or figures separately
• Add a column for manual notes or edits

Scale Your Workflow:

• Create a batch processing version that accepts multiple topics
• Connect to a form or database for automated topic submission
• Add error handling and retry logic for robustness
• Implement notifications when summaries are generated

Advanced Usage Tips

Create Topic Lists: Build a separate sheet with topics to research, then loop through them automatically for bulk processing.

Add Quality Checks: Insert a node that analyzes summary length, keyword presence, or readability scores before saving.

Multi-Language Support: Modify the Wikipedia Search API to target different language versions (e.g., es.wikipedia.org for Spanish).

Custom Formatting: Enhance the Format AI Output node to add markdown formatting, bullet points, or section headers.

Integration with Other Tools: Connect the output to Slack, email, or content management systems for immediate distribution.

Version Control: Add a version number column to track iterations and improvements to your summaries over time.

---

You now have a fully functional, automated history research assistant that saves hours of manual work. Start generating summaries, refine your configuration based on results, and enjoy the power of AI-driven research automation!