Upload 16 files

ZZ_auto_blogger_workflow.json

@@ -0,0 +1,1244 @@
+{
+  "name": "ZZ_auto_blogger_workflow",
+  "nodes": [
+    {
+      "parameters": {
+        "documentId": {
+          "__rl": true,
+          "value": "17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc",
+          "mode": "list",
+          "cachedResultName": "Cluster Template",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc/edit?usp=drivesdk"
+        },
+        "sheetName": {
+          "__rl": true,
+          "value": 1281006823,
+          "mode": "list",
+          "cachedResultName": "Pillar #1",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc/edit#gid=1281006823"
+        },
+        "filtersUI": {
+          "values": [
+            {
+              "lookupColumn": "Status",
+              "lookupValue": "no"
+            }
+          ]
+        },
+        "options": {
+          "returnFirstMatch": true
+        }
+      },
+      "type": "n8n-nodes-base.googleSheets",
+      "typeVersion": 4.5,
+      "position": [
+        320,
+        500
+      ],
+      "id": "7d5168e8-627c-4a8e-b92f-525060bbd7b8",
+      "name": "Grab New Cluster",
+      "credentials": {
+        "googleSheetsOAuth2Api": {
+          "id": "hYWAsZKxwadxEltt",
+          "name": "Google Sheets account 2"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "assignments": {
+          "assignments": [
+            {
+              "id": "23b8e8c4-9191-415a-9661-1b60d413528a",
+              "name": "research",
+              "value": "={{ $json.choices[0].message.content.replaceAll(\"[1]\", \" - source: \" +$json.citations[0]).replaceAll(\"[2]\",\" source:\" +$json.citations[1]).replaceAll(\"[3]\",\" - source: \" +$json.citations[2]).replaceAll(\"[4]\",\" - source: \"+$json.citations[3]).replaceAll(\"[5]\",\" - source: \"+$json.citations[4]).replaceAll(\"[6]\",\" - source: \"+$json.citations[5]).replaceAll(\"[7]\",\" - source: \"+$json.citations[6]).replaceAll(\"[8]\",\" - source: \"+$json.citations[7]).replaceAll(\"[9]\",\" - source: \"+$json.citations[8]).replaceAll(\"[10]\",\" - source: \"+$json.citations[9]) }}",
+              "type": "string"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.set",
+      "typeVersion": 3.4,
+      "position": [
+        1060,
+        500
+      ],
+      "id": "8b7b68a5-7c40-408e-ad25-9c849a4e1322",
+      "name": "Fix Links"
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "o1-preview",
+          "mode": "list",
+          "cachedResultName": "O1-PREVIEW"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=You are part of a team that creates world class blog posts. \n\nFor each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings and a preliminary blog post plan. Here's a definition of each of the inputs: \n\n- Keywords: These are the keywordswhich the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO. \n\n- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post. \n\n- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable. \n\n- Preliminary plan: Very basic plan set out by your colleague to kick off the blog post. \n\n- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections. \n\n\nGiven the said info, you must create a detailed plan for the blog post. \n \nYour output must: \n\n- Include a plan for the blog post.\n\n- Be in dot point format. \n\n- In each part of the blog post, you must mention which keywords should be placed. \n\nHere are the other things you must consider: \n\n- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense. \n\n- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks. \n\n- You must ensure that the plan created satisfies the search intent and revolves directly around the given keywords. \n\n- Your plan must be very detailed. \n\n- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. So your plan should include all technical detail regarding each point to be in the blog post. For example instead of saying \"define X\", you must have \"define X as ...\". \n\n- The plan you create must have a flow that makes sense. \n\n- You must ensure the bog post will be highly detailed and satisfy the most important concepts regarding the topic. \n\nA new project has just came across your desk with below details:\n\nKeywords: \n{{ $('Grab New Cluster').item.json.Keywords }} \n\nSearch intent: \n{{ $('Grab New Cluster').item.json.Intent }}\n\nPreliminary plan: \n{{ $('AI Agent').item.json.output }}\n\nResearch findings: \n{{ $json.research }}\n\nPrimary keyword: \n{{ $('Grab New Cluster').item.json['Primary Keyword'] }}\n\nCreate the detailed plan. \n\nYour output must only be the plan and nothing else. \n"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        1260,
+        340
+      ],
+      "id": "f27b622a-2b34-45cb-bcdb-1b39b9582353",
+      "name": "Create plan",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "anthropic/claude-3.5-sonnet:beta",
+          "mode": "id"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=You are part of a team that creates world class blog posts. \n\nYou are the teams best copywriter and are responsible for writing out the actual blog post. \n\nFor each new blog post project you are provided with a detailed plan and research findings. \n\nYour job is to create the blog post by closely following the detailed plan. \n\nThe blog post you create must: \n\n- Follow the plan bit by bit. \n\n- Use short paragraphs. \n\n- Use bullet points and subheadings with keywords where appropriate.  \n\n- Not have any fluff. The content of the blog must be value dense and direct. \n\n- Be very detailed. \n\n- Include the keywords mentioned in each section within that section. \n\n- Use the research as advised by the plan. Make sure to include the link associated with each point you extract from the research at the end of that section in the form of a URL.  \n\n- Place the primary keyword in the blog title, H1 header and early in the introduction. \n\n- Place one keyword for each section in the heading of that section. \n\n-  When possible pepper synonyms of the keywords throughout each section. \n\n- When possible use Latent Semantic Indexing (LSI) keywords and related terms to enhance context (e.g., “robotic process automation” for RPA). \n\n- Be at minimum 2000 to 2500 words long. \n\n- Be suitable for a year 5 reading level. \n\nMake sure to create the entire blog post draft in your first output. Don't stop or cut it short. \n\nHere are the details of your next blog post project: \n\nDetailed Plan: \n{{ $json.message.content }}\n\nDetailed Research: \n{{ $('Fix Links').item.json.research }}\n\n\nWrite the blog post."
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        1560,
+        340
+      ],
+      "id": "9d123969-dd00-4e3c-936d-f878fcb4391a",
+      "name": "Write Blog"
+    },
+    {
+      "parameters": {
+        "aggregate": "aggregateAllItemData",
+        "destinationFieldName": "previous-posts",
+        "options": {}
+      },
+      "type": "n8n-nodes-base.aggregate",
+      "typeVersion": 1,
+      "position": [
+        2040,
+        560
+      ],
+      "id": "64e6c0ac-1b87-4084-9b38-ff97353e9097",
+      "name": "Aggregate"
+    },
+    {
+      "parameters": {
+        "documentId": {
+          "__rl": true,
+          "value": "1CL0L4V288SEygm0BieMRM8t8h7MbcV9bYyzkDc0zInU",
+          "mode": "list",
+          "cachedResultName": "Completed Keywords - Template",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/1CL0L4V288SEygm0BieMRM8t8h7MbcV9bYyzkDc0zInU/edit?usp=drivesdk"
+        },
+        "sheetName": {
+          "__rl": true,
+          "value": 2094827997,
+          "mode": "list",
+          "cachedResultName": "Sheet1",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/1CL0L4V288SEygm0BieMRM8t8h7MbcV9bYyzkDc0zInU/edit#gid=2094827997"
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.googleSheets",
+      "typeVersion": 4.5,
+      "position": [
+        1880,
+        560
+      ],
+      "id": "d7d5d589-fe19-4000-a485-8e9aaa9b9bf2",
+      "name": "Previous Posts",
+      "credentials": {
+        "googleSheetsOAuth2Api": {
+          "id": "hYWAsZKxwadxEltt",
+          "name": "Google Sheets account 2"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "o1-mini-2024-09-12",
+          "mode": "list",
+          "cachedResultName": "O1-MINI-2024-09-12"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=You are part of a team that creates world class blog posts. \n\nYou are in charge of internal linking between blog posts. \n\nFor each new blog post that comes across your desk, your job is to look through previously posted blogs and make atleast 5 internal links. \n\nTo choose the best internal linking opportunities you must: \n\n- Read the previous blog post summaries and look through their keywords. If there is a match where the previous blog post is highly relevant, then this is an internal linking opportunity. \n\n- Do not link if it is not highly relevant. Only make a link if it makes sense and adds value for the reader. \n\nOnce you've found the best linking opportunities, you must update the blog post with the internal links. To do this you must: \n\n- Add the link of the previous blog post at the relevant section of the new blog post. Drop the URL at the place which makes most sense. Later we will hyperlink the URL to the word in the blog post which it is placed next to. So your placing is very important. \n\nMake sure to not delete any existing URLs or change anything about the blog post provided to you. You must only add new internal linking URLs and output the revised blog post. \n\nYour output must be the blog post given to you plus the new urls. Don't remove any info. \n\nDon't return the previous blog posts. Only return the current blog post with the internal links added.\n\nCurrent blog Post: \n{{ $('write blog').item.json.output }}\n\nPrevious Blog Posts: \n{{ $json['previous-posts'].toJsonString().split() }}\n\n"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        2160,
+        400
+      ],
+      "id": "7db6c59e-8fc9-4220-88ae-b991ea6f0ad3",
+      "name": "Add internal links",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "gpt-4o-mini",
+          "mode": "list",
+          "cachedResultName": "GPT-4O-MINI"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=Create a slug for the following blog post: \n{{ $('Add internal links').item.json.message.content }}\n\nA slug in a blog post is the part of the URL that comes after the domain name and identifies a specific page. It is typically a short, descriptive phrase that summarizes the content of the post, making it easier for users and search engines to understand what the page is about. For example, in the URL www.example.com/intelligent-agents, the slug is intelligent-agents. A good slug is concise, contains relevant keywords, and avoids unnecessary words to improve readability and SEO. \n\nThe slug must be 4 or 5 words max and must include the primary keyword of the blog post which is {{ $('Grab New Cluster').last().json['Primary Keyword'] }}.\n\nYour output must be the slug and nothing else so that I can copy and paste your output and put it at the end of my blog post URL to post it right away. "
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        2820,
+        560
+      ],
+      "id": "5defb2d1-ed32-4dc7-a8cc-a0281589421f",
+      "name": "Slug",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "gpt-4o-2024-11-20",
+          "mode": "list",
+          "cachedResultName": "GPT-4O-2024-11-20"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=Extract the blog post title from the following blog post: \n{{ $('Add internal links').item.json.message.content }}\n\n\n\nThe blog post title must include the primary keyword {{ $('Grab New Cluster').last().json['Primary Keyword'] }} and must inform the users right away of what they can expect from reading the blog post. \n\n- Don't put the output in \"\". The output should just text with no markdown or formatting. \n\nYour output must only be the blog post title and nothing else. "
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        3120,
+        560
+      ],
+      "id": "bebffc20-05dd-4d47-b4b6-a1b2210035da",
+      "name": "Title",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "gpt-4o-2024-11-20",
+          "mode": "list",
+          "cachedResultName": "GPT-4O-2024-11-20"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=Create a proper meta description for the following blog post: \n\n{{ $('Add internal links').item.json.message.content }}\n\nA good meta description for a blog post that is SEO-optimized should:\n- Be Concise: Stick to 150-160 characters to ensure the full description displays in search results. \n- Include Keywords: Incorporate primary keywords naturally to improve visibility and relevance to search queries.\n\nPrimary keyword = {{ $('Grab New Cluster').last().json['Primary Keyword'] }}\n\nMore keywords to include if possible = [{{ $('Grab New Cluster').last().json.Keywords }}]\n\n- Provide Value: Clearly describe what the reader will learn or gain by clicking the link. \n\n- Be Engaging: Use persuasive language, such as action verbs or a question, to encourage clicks. \n\n- Align with Content: Ensure the description accurately reflects the blog post to meet user expectations and reduce bounce rates. \n\nYour output must only be the meta description and nothing else. \n"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        3420,
+        560
+      ],
+      "id": "b47c137a-41ff-4741-88a0-15752627cc5d",
+      "name": "Meta description",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "modelId": {
+          "__rl": true,
+          "value": "o1-preview",
+          "mode": "list",
+          "cachedResultName": "O1-PREVIEW"
+        },
+        "messages": {
+          "values": [
+            {
+              "content": "=DO NOT OUTPUT ANYTHING OTHER THAN THE CODE. I want you to follow the layout of the template as a guide to generate the WordPress code for a blog post. Here are the rules to follow:\n\nThe blog post should have a title, estimated reading time, key takeaways, table of contents, body, and FAQ in this order.\nMake it engaging by using italics, dot points, quotes, bold, spaces, and sometimes new lines. Never use emojis.\nThe blog post will have some URLs referenced next to certain keyphrases to show where the info came from. You must hyperlink the keyphrase with the provided URL so that the reader can click on the referenced URL. It is critical you get this right.\nWrap the entire content in a container <div> with inline CSS that sets the text color to white (#ffffff), uses a legible font such as Arial, sans-serif, and sets line-height to 1.6.\nEnsure that all non-heading text elements (e.g., paragraphs, list items) have an inline style or embedded style that sets their font size to 20px and color to white (#ffffff) using !important to override theme styles.\nHyperlinks, points in the table of contents, and FAQ questions must be styled in blue (#00c2ff).\nAll headings and subheadings should have an underline implemented via a bottom border in blue (#00c2ff) with appropriate padding.\nPlace a double break (<br><br>) between each section to improve readability.\nDo not output any extra text or mention code tags like HTML''' around the output; just output the HTML code.\nBlog post: \n\n{{ $json.message.content }}\n\nHere's an example of a well formatted output:\n\n<div style=\"color: #ffffff; font-family: Arial, sans-serif; line-height: 1.6;\"> <style> p, .wp-block-paragraph, ul.wp-block-list, li { color: #ffffff !important; font-size: 20px !important; } a { color: #00c2ff !important; } </style> <h1 id=\"h-devin-ai-the-hype-and-reality-of-an-ai-software-engineer\" class=\"wp-block-heading\" style=\"border-bottom: 2px solid #00c2ff; padding-bottom: 5px;\">Devin AI: The Hype and Reality of an AI Software Engineer</h1> <br><br> <p class=\"estimated-reading-time\" style=\"color: #ffffff; font-size: 20px !important;\">Estimated reading time: 5 minutes</p> <br><br> <h2 id=\"h-key-takeaways\" class=\"wp-block-heading\" style=\"border-bottom: 2px solid #00c2ff; padding-bottom: 5px;\"><strong>Key Takeaways</strong></h2> <br><br> <ul class=\"wp-block-list\"> <li><mark style=\"background-color: #ffd966;\"><strong>Devin AI</strong></mark> claims to be the world's first fully autonomous AI software engineer.</li> <br><br> <li>Initial demos and claims have generated significant <mark style=\"background-color: #ffff00;\">hype</mark> and interest.</li> <br><br> <li>Critics argue some capabilities may be exaggerated or misleading.</li> <br><br> <li>Real-world testing reveals both <em>strengths</em> and <em>limitations</em>.</li> <br><br> <li>The true impact on software engineering remains to be seen.</li> </ul> <br><br> <div class=\"wp-block-yoast-seo-table-of-contents yoast-table-of-contents\"> <h2 style=\"color: #ffffff; border-bottom: 2px solid #00c2ff; padding-bottom: 5px;\">Table of contents</h2> <br><br> <ul> <li><a href=\"#h-devin-ai-the-hype-and-reality-of-an-ai-software-engineer\" data-level=\"1\">Devin AI: The Hype and Reality of an AI Software Engineer</a></li> <br><br> <li><a href=\"#h-key-takeaways\" data-level=\"2\">Key Takeaways</a></li> <br><br> <li><a href=\"#h-what-is-devin-ai\" data-level=\"2\">What is Devin AI?</a></li> <br><br> <li><a href=\"#h-the-hype-around-devin-ai\" data-level=\"2\">The Hype Around Devin AI</a></li> <br><br> <li><a href=\"#h-putting-devin-to-the-test\" data-level=\"2\">Putting Devin to the Test</a></li> <br><br> <li><a href=\"#h-the-reality-check\" data-level=\"2\">The Reality Check</a></li> <br><br> <li><a href=\"#h-the-future-of-ai-in-software-development\" data-level=\"2\">The Future of AI in Software Development</a></li> <br><br> <li><a href=\"#h-frequently-asked-questions\" data-level=\"2\">Frequently Asked Questions</a></li> </ul> </div> <br><br> <p>Devin AI has burst onto the tech scene, promising to revolutionize software development as we know it. But does this AI-powered coding assistant live up to the hype? Let's dive into what Devin AI really is, what it can do, and what developers are saying after putting it to the test.</p> <br><br> <!-- Rest of blog post content goes here --> </div>\n"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.openAi",
+      "typeVersion": 1.8,
+      "position": [
+        2500,
+        400
+      ],
+      "id": "23500c58-54c0-4ded-bae8-4819e8af1cde",
+      "name": "HTML version",
+      "credentials": {
+        "openAiApi": {
+          "id": "EF5N3ckj25m5tqQ1",
+          "name": "OpenAi account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "url": "https://serpapi.com/search?engine=google_images",
+        "authentication": "genericCredentialType",
+        "genericAuthType": "httpQueryAuth",
+        "sendQuery": true,
+        "queryParameters": {
+          "parameters": [
+            {
+              "name": "q",
+              "value": "={{ $('Title').item.json.message.content }}"
+            },
+            {
+              "name": "gl",
+              "value": "us"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        3740,
+        560
+      ],
+      "id": "50308aaf-b6e3-4e5e-9e9d-d1fa7d2e1cb3",
+      "name": "Image Covers",
+      "credentials": {
+        "httpQueryAuth": {
+          "id": "1NakbreMhEpbJspl",
+          "name": "SerpAPI"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "assignments": {
+          "assignments": [
+            {
+              "id": "1f0541df-05ab-4e3d-a5d8-3904579fc8a9",
+              "name": "image-url",
+              "value": "={{ $json.images_results[1].original }}",
+              "type": "string"
+            }
+          ]
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.set",
+      "typeVersion": 3.4,
+      "position": [
+        3900,
+        560
+      ],
+      "id": "b6f5e04b-841b-4ade-94f6-8213a2370939",
+      "name": "Edit Fields"
+    },
+    {
+      "parameters": {
+        "operation": "appendOrUpdate",
+        "documentId": {
+          "__rl": true,
+          "value": "17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc",
+          "mode": "list",
+          "cachedResultName": "Cluster Template",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc/edit?usp=drivesdk"
+        },
+        "sheetName": {
+          "__rl": true,
+          "value": 1281006823,
+          "mode": "list",
+          "cachedResultName": "Pillar #1",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/17gUjLgjmJpXHcwsYPkZRG3salzsFLw3ZC3l4GT9liEc/edit#gid=1281006823"
+        },
+        "columns": {
+          "mappingMode": "defineBelow",
+          "value": {},
+          "matchingColumns": [
+            "Status"
+          ],
+          "schema": [
+            {
+              "id": "Cluster",
+              "displayName": "Cluster",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Intent",
+              "displayName": "Intent",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Keywords",
+              "displayName": "Keywords",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Primary Keyword",
+              "displayName": "Primary Keyword",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Status",
+              "displayName": "Status",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true,
+              "removed": false
+            },
+            {
+              "id": "row_number",
+              "displayName": "row_number",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true,
+              "readOnly": true,
+              "removed": true
+            }
+          ],
+          "attemptToConvertTypes": false,
+          "convertFieldsToString": false
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.googleSheets",
+      "typeVersion": 4.5,
+      "position": [
+        4380,
+        560
+      ],
+      "id": "7caa939e-eca3-4a03-8673-383fab605b6f",
+      "name": "Check as completed on Sheets",
+      "credentials": {
+        "googleSheetsOAuth2Api": {
+          "id": "hYWAsZKxwadxEltt",
+          "name": "Google Sheets account 2"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "operation": "append",
+        "documentId": {
+          "__rl": true,
+          "value": "1t-J2x22lsG6TpktQLBkwaS-ewuJI2WQvB-g4vQspbYU",
+          "mode": "list",
+          "cachedResultName": "Completed Keywords",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/1t-J2x22lsG6TpktQLBkwaS-ewuJI2WQvB-g4vQspbYU/edit?usp=drivesdk"
+        },
+        "sheetName": {
+          "__rl": true,
+          "value": "gid=0",
+          "mode": "list",
+          "cachedResultName": "Sheet1",
+          "cachedResultUrl": "https://docs.google.com/spreadsheets/d/1t-J2x22lsG6TpktQLBkwaS-ewuJI2WQvB-g4vQspbYU/edit#gid=0"
+        },
+        "columns": {
+          "mappingMode": "defineBelow",
+          "value": {
+            "Blog Title ": "={{ $('Title').item.json.message.content }}",
+            "Keywords": "={{ $('Grab New Cluster').last().json.Keywords }}",
+            "Summary ": "={{ $('Meta description').item.json.message.content }}",
+            "URL": "=https://YourURL/{{ $('Slug').item.json.message.content }}"
+          },
+          "matchingColumns": [],
+          "schema": [
+            {
+              "id": "Blog Title ",
+              "displayName": "Blog Title ",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Keywords",
+              "displayName": "Keywords",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "Summary ",
+              "displayName": "Summary ",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            },
+            {
+              "id": "URL",
+              "displayName": "URL",
+              "required": false,
+              "defaultMatch": false,
+              "display": true,
+              "type": "string",
+              "canBeUsedToMatch": true
+            }
+          ],
+          "attemptToConvertTypes": false,
+          "convertFieldsToString": false
+        },
+        "options": {}
+      },
+      "type": "n8n-nodes-base.googleSheets",
+      "typeVersion": 4.5,
+      "position": [
+        4580,
+        560
+      ],
+      "id": "e64ef24c-f842-4349-a021-b225a523013d",
+      "name": "Google Sheets"
+    },
+    {
+      "parameters": {
+        "content": "## Schedule a trigger\n \n",
+        "height": 240,
+        "width": 260
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        20,
+        400
+      ],
+      "typeVersion": 1,
+      "id": "4a45ccd8-70ef-4637-9e59-e2377d098956",
+      "name": "Sticky Note"
+    },
+    {
+      "parameters": {
+        "content": "## New Post Info\n \n",
+        "height": 240
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        280,
+        400
+      ],
+      "typeVersion": 1,
+      "id": "d6d3858c-05ef-40f1-ab03-e1d7cad7222a",
+      "name": "Sticky Note1"
+    },
+    {
+      "parameters": {
+        "content": "## Preliminary Post Plan \n \n",
+        "height": 680,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        520,
+        400
+      ],
+      "typeVersion": 1,
+      "id": "effc3813-a919-4a5b-816e-bb669a296276",
+      "name": "Sticky Note2"
+    },
+    {
+      "parameters": {
+        "content": "## Research\n \n \n",
+        "height": 240,
+        "width": 180
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        820,
+        400
+      ],
+      "typeVersion": 1,
+      "id": "43e9adff-1cfd-41a6-ab0f-e4063759259d",
+      "name": "Sticky Note3"
+    },
+    {
+      "parameters": {
+        "content": "## Post Plan \n \n",
+        "height": 580,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        1240,
+        260
+      ],
+      "typeVersion": 1,
+      "id": "ce402266-f43d-41ad-a7bc-b249ce1753f2",
+      "name": "Sticky Note4"
+    },
+    {
+      "parameters": {
+        "content": "## Writing Blog\n \n \n",
+        "height": 580,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        1540,
+        260
+      ],
+      "typeVersion": 1,
+      "id": "b0e13017-ca7d-4f1a-8fac-c0f0857f1bd1",
+      "name": "Sticky Note5"
+    },
+    {
+      "parameters": {
+        "method": "POST",
+        "url": "https://api.perplexity.ai/chat/completions",
+        "authentication": "genericCredentialType",
+        "genericAuthType": "httpHeaderAuth",
+        "sendBody": true,
+        "specifyBody": "json",
+        "jsonBody": "={\n      \"model\": \"sonar-pro\",\n    \"messages\": [\n        {\n            \"role\": \"system\",\n            \"content\": \"Act as a professional news researcher who is capable of finding detailed summaries about a news topic from highly reputable sources.\"\n        },\n        {\n            \"role\": \"user\",\n            \"content\": \" You are helping research for a blog article. Please provide in depth research for each of the titles of the following blog plan:{{ $json.output.split(/\\n+/).join(' ')}}\"\n        }\n    ]\n}",
+        "options": {}
+      },
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        860,
+        500
+      ],
+      "id": "d6256dfe-516e-441d-b426-beaa68cd0796",
+      "name": "Research",
+      "credentials": {
+        "httpHeaderAuth": {
+          "id": "oEBlGZGtMD64v00n",
+          "name": "Perplexity Auth"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "content": "## Internal Links\n \n \n",
+        "height": 240,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        2140,
+        320
+      ],
+      "typeVersion": 1,
+      "id": "a658fcbd-cd00-4734-a456-2ec888238a8e",
+      "name": "Sticky Note6"
+    },
+    {
+      "parameters": {
+        "content": "## HTML\n\n \n \n",
+        "height": 240,
+        "width": 340
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        2440,
+        320
+      ],
+      "typeVersion": 1,
+      "id": "55806213-1d1b-4d82-96df-a8be158f63b6",
+      "name": "Sticky Note7"
+    },
+    {
+      "parameters": {
+        "content": "## Slug\n\n\n \n \n",
+        "height": 240,
+        "width": 320
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        2780,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "8c5f22e8-b48c-41c9-a153-69d6a39d6d23",
+      "name": "Sticky Note8"
+    },
+    {
+      "parameters": {
+        "content": "## Post Title\n\n\n \n \n",
+        "height": 240,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        3100,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "01441f93-8e77-42c8-9e29-3d65963bf6e5",
+      "name": "Sticky Note9"
+    },
+    {
+      "parameters": {
+        "content": "## Meta Description\n\n\n \n \n",
+        "height": 240,
+        "width": 300
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        3400,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "1b422deb-65fa-4b14-a23d-aed00321c077",
+      "name": "Sticky Note10"
+    },
+    {
+      "parameters": {
+        "content": "## Get Image\n\n\n\n \n \n",
+        "height": 240,
+        "width": 360
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        3700,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "74113fdc-bd62-4f4e-8b9e-46c7f25d431b",
+      "name": "Sticky Note11"
+    },
+    {
+      "parameters": {
+        "content": "## Post\n\n\n\n\n \n \n",
+        "height": 240,
+        "width": 220
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        4060,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "c9ac7046-4d1c-4731-81cf-7a452b1c0d93",
+      "name": "Sticky Note12"
+    },
+    {
+      "parameters": {
+        "title": "={{ $('Title').item.json.message.content }}",
+        "additionalFields": {
+          "authorId": 2,
+          "content": "=<img src=\"{{ $json['image-url'] }}\" alt=\"Cover Image\">\n{{ $('HTML version').item.json.message.content }}",
+          "slug": "={{ $('Slug').item.json.message.content }}",
+          "status": "draft",
+          "commentStatus": "closed",
+          "sticky": false,
+          "categories": [
+            280
+          ],
+          "tags": [
+            281
+          ],
+          "postTemplate": {
+            "values": {}
+          }
+        }
+      },
+      "type": "n8n-nodes-base.wordpress",
+      "typeVersion": 1,
+      "position": [
+        4140,
+        560
+      ],
+      "id": "7c623a61-bffa-4a08-b2ed-5b01535c963b",
+      "name": "Wordpress",
+      "credentials": {
+        "wordpressApi": {
+          "id": "apQBpnJI8R7EgZZ4",
+          "name": "Wordpress account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "content": "## Completion\n\n\n\n\n\n \n \n",
+        "height": 240,
+        "width": 480
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        4300,
+        480
+      ],
+      "typeVersion": 1,
+      "id": "4ae2ad80-3597-4941-80ee-e5e0b2fdc313",
+      "name": "Sticky Note13"
+    },
+    {
+      "parameters": {
+        "content": "# CLUSTER SEO POST\n\n \n \n",
+        "height": 100,
+        "width": 500,
+        "color": 4
+      },
+      "type": "n8n-nodes-base.stickyNote",
+      "position": [
+        0,
+        0
+      ],
+      "typeVersion": 1,
+      "id": "76007e96-7941-40d5-8760-4464c189f067",
+      "name": "Sticky Note14"
+    },
+    {
+      "parameters": {},
+      "type": "n8n-nodes-base.manualTrigger",
+      "typeVersion": 1,
+      "position": [
+        100,
+        500
+      ],
+      "id": "ba79c1f5-a3e3-4af0-a7c3-6435b5160743",
+      "name": "When clicking ‘Test workflow’"
+    },
+    {
+      "parameters": {
+        "model": "deepseek/deepseek-r1:free",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+      "typeVersion": 1,
+      "position": [
+        600,
+        720
+      ],
+      "id": "2f3c3ba8-04f0-4380-a7d3-b8b86026f82f",
+      "name": "OpenRouter Chat Model",
+      "credentials": {
+        "openRouterApi": {
+          "id": "vujYaSViYHNMVXm9",
+          "name": "OpenRouter account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "promptType": "define",
+        "text": "=You are part of a team that creates world class blog posts. \n\nFor each new blog post project, you are provided with a list of keywords and search intent. \n\n- Keywords: The keywords are to what the blog post is meant to rank for. They are scattered throughout the blog and define the topic of the blog post. \n\n- Search intent: The search intent recognises the intent of the user when searching up the keyword which defines be the theme of the blog post, so they click on our blog to satisfy their search. \n\n- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword will go in the title and first few sentences. It is important that the topic of the blog post is related to the primary keyword so that you can place it into the title and introduction naturally. \n\nGiven a list of keywords and search intent, your job is to understand the goal of th e blog post, identify the thought process behind the flow of the blog post and come up with a preliminary plan for the post. \n\nYour output must: \n\n- Recognise the discussion points of the blog post.\n\n- Be in dot point format.\n\nYou must ensure that the plan created satisfies the search intent and revolves directly around the given keywords. \n\nWhen making the plan keep in mind that all keywords must be used in the final blog post. \n\nThe final goal of the project is to create a high quality, high value, highly relevant blog post that will satisfy the users search intent and give them everything they need to know about the topic. \n\nA new project just came across your desk with below keywords and search intent:\n\nKeywords: \n{{ $json.Keywords }}\n\nSearch intent: \n{{ $json.Intent }}\n\nPrimary keyword: \n{{ $json['Primary Keyword'] }}\n\nCreate the preliminary plan.",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.agent",
+      "typeVersion": 1.7,
+      "position": [
+        560,
+        520
+      ],
+      "id": "e091badf-8a0d-464a-a4bb-7bce60c270cb",
+      "name": "AI Agent"
+    },
+    {
+      "parameters": {
+        "model": "deepseek/deepseek-r1:free",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+      "typeVersion": 1,
+      "position": [
+        1300,
+        700
+      ],
+      "id": "a4f3a398-20d2-425c-9a87-1d2b98e72171",
+      "name": "OpenRouter Chat Model1",
+      "credentials": {
+        "openRouterApi": {
+          "id": "vujYaSViYHNMVXm9",
+          "name": "OpenRouter account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "promptType": "define",
+        "text": "=You are part of a team that creates world class blog posts. \n\nFor each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings and a preliminary blog post plan. Here's a definition of each of the inputs: \n\n- Keywords: These are the keywordswhich the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO. \n\n- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post. \n\n- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable. \n\n- Preliminary plan: Very basic plan set out by your colleague to kick off the blog post. \n\n- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections. \n\n\nGiven the said info, you must create a detailed plan for the blog post. \n \nYour output must: \n\n- Include a plan for the blog post.\n\n- Be in dot point format. \n\n- In each part of the blog post, you must mention which keywords should be placed. \n\nHere are the other things you must consider: \n\n- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense. \n\n- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks. \n\n- You must ensure that the plan created satisfies the search intent and revolves directly around the given keywords. \n\n- Your plan must be very detailed. \n\n- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. So your plan should include all technical detail regarding each point to be in the blog post. For example instead of saying \"define X\", you must have \"define X as ...\". \n\n- The plan you create must have a flow that makes sense. \n\n- You must ensure the bog post will be highly detailed and satisfy the most important concepts regarding the topic. \n\nA new project has just came across your desk with below details:\n\nKeywords: \n{{ $('Grab New Cluster').item.json.Keywords }} \n\nSearch intent: \n{{ $('Grab New Cluster').item.json.Intent }}\n\nPreliminary plan: \n{{ $('AI Agent').item.json.output }}\n\nResearch findings: \n{{ $json.research }}\n\nPrimary keyword: \n{{ $('Grab New Cluster').item.json['Primary Keyword'] }}\n\nCreate the detailed plan. \n\nYour output must only be the plan and nothing else. \n",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.agent",
+      "typeVersion": 1.7,
+      "position": [
+        1260,
+        540
+      ],
+      "id": "e5a5cea2-3426-40f0-8d90-ddf87b7cc92a",
+      "name": "create plan"
+    },
+    {
+      "parameters": {
+        "model": "google/gemini-2.0-pro-exp-02-05:free",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+      "typeVersion": 1,
+      "position": [
+        1580,
+        700
+      ],
+      "id": "2371f47b-8cf1-4003-988e-0d057caf9120",
+      "name": "OpenRouter Chat Model2",
+      "credentials": {
+        "openRouterApi": {
+          "id": "vujYaSViYHNMVXm9",
+          "name": "OpenRouter account"
+        }
+      }
+    },
+    {
+      "parameters": {
+        "promptType": "define",
+        "text": "=You are part of a team that creates world class blog posts. \n\nFor each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings and a preliminary blog post plan. Here's a definition of each of the inputs: \n\n- Keywords: These are the keywordswhich the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO. \n\n- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post. \n\n- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable. \n\n- Preliminary plan: Very basic plan set out by your colleague to kick off the blog post. \n\n- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections. \n\n\nGiven the said info, you must create a detailed plan for the blog post. \n \nYour output must: \n\n- Include a plan for the blog post.\n\n- Be in dot point format. \n\n- In each part of the blog post, you must mention which keywords should be placed. \n\nHere are the other things you must consider: \n\n- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense. \n\n- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks. \n\n- You must ensure that the plan created satisfies the search intent and revolves directly around the given keywords. \n\n- Your plan must be very detailed. \n\n- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. So your plan should include all technical detail regarding each point to be in the blog post. For example instead of saying \"define X\", you must have \"define X as ...\". \n\n- The plan you create must have a flow that makes sense. \n\n- You must ensure the bog post will be highly detailed and satisfy the most important concepts regarding the topic. \n\nA new project has just came across your desk with below details:\n\nKeywords: \n{{ $('Grab New Cluster').item.json.Keywords }} \n\nSearch intent: \n{{ $('Grab New Cluster').item.json.Intent }}\n\nPreliminary plan: \n{{ $('AI Agent').item.json.output }}\n\nResearch findings: {{ $('Fix Links').item.json.research }}\n\nPrimary keyword: \n{{ $('Grab New Cluster').item.json['Primary Keyword'] }}\n\nCreate the detailed plan. \n\nYour output must only be the plan and nothing else. \n",
+        "options": {}
+      },
+      "type": "@n8n/n8n-nodes-langchain.agent",
+      "typeVersion": 1.7,
+      "position": [
+        1560,
+        540
+      ],
+      "id": "eb8811f8-d821-45b3-9807-472c6d7a2b00",
+      "name": "write blog"
+    }
+  ],
+  "pinData": {},
+  "connections": {
+    "Grab New Cluster": {
+      "main": [
+        [
+          {
+            "node": "AI Agent",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Fix Links": {
+      "main": [
+        [
+          {
+            "node": "create plan",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Create plan": {
+      "main": [
+        [
+          {
+            "node": "Write Blog",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Write Blog": {
+      "main": [
+        []
+      ]
+    },
+    "Previous Posts": {
+      "main": [
+        [
+          {
+            "node": "Aggregate",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Aggregate": {
+      "main": [
+        [
+          {
+            "node": "Add internal links",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Add internal links": {
+      "main": [
+        [
+          {
+            "node": "HTML version",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Slug": {
+      "main": [
+        [
+          {
+            "node": "Title",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Title": {
+      "main": [
+        [
+          {
+            "node": "Meta description",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "HTML version": {
+      "main": [
+        [
+          {
+            "node": "Slug",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Meta description": {
+      "main": [
+        [
+          {
+            "node": "Image Covers",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Image Covers": {
+      "main": [
+        [
+          {
+            "node": "Edit Fields",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Edit Fields": {
+      "main": [
+        [
+          {
+            "node": "Wordpress",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Check as completed on Sheets": {
+      "main": [
+        [
+          {
+            "node": "Google Sheets",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Research": {
+      "main": [
+        [
+          {
+            "node": "Fix Links",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Wordpress": {
+      "main": [
+        [
+          {
+            "node": "Check as completed on Sheets",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "When clicking ‘Test workflow’": {
+      "main": [
+        [
+          {
+            "node": "Grab New Cluster",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "OpenRouter Chat Model": {
+      "ai_languageModel": [
+        [
+          {
+            "node": "AI Agent",
+            "type": "ai_languageModel",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "AI Agent": {
+      "main": [
+        [
+          {
+            "node": "Research",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "OpenRouter Chat Model1": {
+      "ai_languageModel": [
+        [
+          {
+            "node": "create plan",
+            "type": "ai_languageModel",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "create plan": {
+      "main": [
+        [
+          {
+            "node": "write blog",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "OpenRouter Chat Model2": {
+      "ai_languageModel": [
+        [
+          {
+            "node": "write blog",
+            "type": "ai_languageModel",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "write blog": {
+      "main": [
+        [
+          {
+            "node": "Previous Posts",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    }
+  },
+  "active": false,
+  "settings": {
+    "executionOrder": "v1"
+  },
+  "versionId": "9675df72-5405-47aa-aa5f-bd92f445cb59",
+  "meta": {
+    "instanceId": "56bde12b420ee12a1a73bd1e14e7f4194c37cc35508d2c95d81da646ef78f5b4"
+  },
+  "id": "9xOE18PxbY5Yqgo1",
+  "tags": [
+    {
+      "createdAt": "2025-02-11T11:45:04.228Z",
+      "updatedAt": "2025-02-11T11:45:04.228Z",
+      "id": "1v5wgolm1yGcSkAA",
+      "name": "marketing-automation"
+    }
+  ]
+}

app.py

@@ -0,0 +1,462 @@
+from flask import Flask, request, jsonify
+import os
+from dotenv import load_dotenv
+import requests
+from blog_generator import BlogGenerator
+from csv_handler import CSVHandler
+import ssl
+import logging
+from web_scraper import research_topic
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+load_dotenv()
+
+# Configuration
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY')
+PERPLEXITY_API_KEY = os.getenv('PERPLEXITY_API_KEY')
+SERPAPI_API_KEY = os.getenv('SERPAPI_API_KEY')
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def generate_preliminary_plan(cluster_data):
+    logger.info("Generating preliminary plan...")
+    try:
+        response = requests.post(
+            'https://openrouter.ai/api/v1/chat/completions',
+            headers={
+                'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+                'HTTP-Referer': 'http://127.0.0.1:5001',
+                'X-Title': 'Blog Generator'
+            },
+            json={
+                'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                'messages': [{
+                    'role': 'user',
+                    'content': f"""You are part of a team that creates world class blog posts.
+
+For each new blog post project, you are provided with a list of keywords and search intent.
+
+- Keywords: The keywords are to what the blog post is meant to rank for. They are scattered throughout the blog and define the topic of the blog post.
+
+- Search intent: The search intent recognises the intent of the user when searching up the keyword which defines be the theme of the blog post, so they click on our blog to satisfy their search.
+
+- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword will go in the title and first few sentences. It is important that the topic of the blog post is related to the primary keyword so that you can place it into the title and introduction naturally.
+
+Given a list of keywords and search intent, your job is to understand the goal of the blog post, identify the thought process behind the flow of the blog post and come up with a preliminary plan for the post.
+
+Your output must:
+- Recognise the discussion points of the blog post.
+- Be in dot point format.
+
+You must ensure that the plan created satisfies the search intent and revolves directly around the given keywords.
+
+When making the plan keep in mind that all keywords must be used in the final blog post.
+
+The final goal of the project is to create a high quality, high value, highly relevant blog post that will satisfy the users search intent and give them everything they need to know about the topic.
+
+A new project just came across your desk with below keywords and search intent:
+
+Keywords:
+{cluster_data['Keywords']}
+
+Search intent:
+{cluster_data['Intent']}
+
+Primary keyword:
+{cluster_data['Primary Keyword']}
+
+Create the preliminary plan."""
+                }]
+            },
+            timeout=60
+        )
+        
+        logger.info(f"OpenRouter API Response: {response.text}")
+        
+        if response.status_code != 200:
+            raise Exception(f"OpenRouter API error: {response.text}")
+            
+        response_data = response.json()
+        if 'choices' not in response_data:
+            raise Exception(f"Unexpected API response format: {response_data}")
+            
+        return response_data['choices'][0]['message']['content']
+    except Exception as e:
+        logger.error(f"Error in generate_preliminary_plan: {e}")
+        raise
+
+def do_research(plan):
+    logger.info("Doing research...")
+    try:
+        # Extract key points from plan to create search queries
+        plan_lines = [line.strip('* -').strip() for line in plan.split('\n') if line.strip()]
+        
+        # Take only the first 3 points
+        plan_lines = plan_lines[:3]
+        logger.info(f"Researching top 3 points: {plan_lines}")
+        
+        all_research = []
+        
+        # Research each main point in the plan (limited to 3 points)
+        for point in plan_lines:
+            if not point:  # Skip empty lines
+                continue
+                
+            # Get research results including both web content and AI analysis
+            # Using 5 sites per point for more comprehensive research
+            results = research_topic(point, num_sites=5)
+            
+            if results['success']:
+                all_research.append({
+                    'topic': point,
+                    'analysis': results['analysis'],
+                    'sources': results['sources']
+                })
+        
+        # Format all research into a comprehensive markdown document
+        formatted_research = "# Research Results\n\n"
+        
+        for research in all_research:
+            formatted_research += f"## {research['topic']}\n\n"
+            formatted_research += f"{research['analysis']}\n\n"
+            formatted_research += "### Sources Referenced\n\n"
+            
+            for source in research['sources']:
+                formatted_research += f"- [{source['title']}]({source['source']})\n"
+                if source['meta_info']['description']:
+                    formatted_research += f"  {source['meta_info']['description']}\n"
+            
+            formatted_research += "\n---\n\n"
+        
+        return formatted_research
+        
+    except Exception as e:
+        logger.error(f"Error in do_research: {e}")
+        raise
+
+@app.route('/generate-blog', methods=['POST'])
+def generate_blog():
+    try:
+        logger.info("Starting blog generation process for multiple clusters...")
+        
+        # Initialize handlers
+        blog_gen = BlogGenerator(OPENAI_API_KEY, OPENROUTER_API_KEY)
+        csv_handler = CSVHandler()
+
+        generated_blogs = []
+        
+        # Get all available clusters
+        all_clusters = csv_handler.get_all_clusters()
+        
+        for cluster_data in all_clusters:
+            try:
+                logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
+                
+                # 2. Generate preliminary plan
+                logger.info("Generating preliminary plan...")
+                plan = generate_preliminary_plan(cluster_data)
+
+                # 3. Do research
+                logger.info("Doing research...")
+                research = do_research(plan)
+
+                # 4. Create detailed plan
+                logger.info("Creating detailed plan...")
+                detailed_plan = blog_gen.create_detailed_plan(cluster_data, plan, research)
+
+                # 5. Write blog post
+                logger.info("Writing blog post...")
+                blog_content = blog_gen.write_blog_post(detailed_plan, cluster_data)
+
+                # 6. Add internal links
+                logger.info("Adding internal links...")
+                previous_posts = csv_handler.get_previous_posts()
+                blog_content = blog_gen.add_internal_links(blog_content, previous_posts)
+
+                # 7. Convert to HTML
+                logger.info("Converting to HTML...")
+                cover_image_url = blog_gen.get_cover_image(cluster_data['Primary Keyword'])
+                html_content = blog_gen.convert_to_html(blog_content, cover_image_url)
+
+                # 8. Generate metadata
+                logger.info("Generating metadata...")
+                metadata = blog_gen.generate_metadata(blog_content, cluster_data['Primary Keyword'], cluster_data)
+
+                # 9. Get cover image
+                logger.info("Getting cover image...")
+                cover_image_url = blog_gen.get_cover_image(metadata['title'])
+
+                # Create blog post data
+                blog_post_data = {
+                    'title': metadata['title'],
+                    'slug': metadata['slug'],
+                    'meta_description': metadata['meta_description'],
+                    'content': html_content,
+                    'cover_image': cover_image_url,
+                    'keywords': cluster_data['Keywords'],
+                    'primary_keyword': cluster_data['Primary Keyword'],
+                    'research': research,
+                    'detailed_plan': detailed_plan
+                }
+
+                # 10. Update tracking CSVs
+                logger.info("Updating tracking CSVs...")
+                csv_handler.mark_cluster_complete(cluster_data['row_number'])
+                csv_handler.log_completed_post({**metadata, 'keywords': cluster_data['Keywords']})
+
+                # Add to generated blogs array
+                generated_blogs.append({
+                    'status': 'success',
+                    'message': f"Blog post generated successfully for {cluster_data['Primary Keyword']}",
+                    'data': blog_post_data
+                })
+
+            except Exception as e:
+                logger.error(f"Error processing cluster {cluster_data['Primary Keyword']}: {e}")
+                generated_blogs.append({
+                    'status': 'error',
+                    'message': f"Failed to generate blog post for {cluster_data['Primary Keyword']}",
+                    'error': str(e)
+                })
+
+        logger.info("All blog generation completed!")
+        return jsonify({
+            'status': 'success',
+            'message': f'Generated {len(generated_blogs)} blog posts',
+            'blogs': generated_blogs
+        })
+
+    except Exception as e:
+        logger.error(f"Error in generate_blog main process: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/test-api', methods=['GET'])
+def test_api():
+    try:
+        # Test OpenRouter API
+        response = requests.post(
+            'https://openrouter.ai/api/v1/chat/completions',
+            headers={
+                'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+                'HTTP-Referer': 'http://localhost:5001',
+                'X-Title': 'Blog Generator'
+            },
+            json={
+                'model': 'deepseek/deepseek-r1',
+                'messages': [{
+                    'role': 'user',
+                    'content': 'Say hello!'
+                }]
+            }
+        )
+        return jsonify({
+            'status': 'success',
+            'openrouter_response': response.json()
+        })
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/generate-from-csv', methods=['POST'])
+def generate_from_csv():
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file uploaded'}), 400
+            
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+            
+        # Read and decode the CSV content
+        csv_content = file.read().decode('utf-8')
+        
+        # Initialize handlers
+        blog_gen = BlogGenerator(OPENAI_API_KEY, OPENROUTER_API_KEY)
+        csv_handler = CSVHandler()
+        
+        # Process the uploaded CSV
+        clusters = csv_handler.process_uploaded_csv(csv_content)
+        
+        if not clusters:
+            return jsonify({'error': 'No valid clusters found in CSV'}), 400
+            
+        generated_blogs = []
+        
+        # Process each cluster
+        for cluster_data in clusters:
+            try:
+                logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
+                
+                # Generate preliminary plan
+                plan = generate_preliminary_plan(cluster_data)
+                
+                # Do research
+                research = do_research(plan)
+                
+                # Create detailed plan
+                detailed_plan = blog_gen.create_detailed_plan(cluster_data, plan, research)
+                
+                # Write blog post
+                blog_content = blog_gen.write_blog_post(detailed_plan, cluster_data)
+                
+                # Add internal links
+                previous_posts = csv_handler.get_previous_posts()
+                blog_content = blog_gen.add_internal_links(blog_content, previous_posts)
+                
+                # Convert to HTML
+                cover_image_url = blog_gen.get_cover_image(cluster_data['Primary Keyword'])
+                html_content = blog_gen.convert_to_html(blog_content, cover_image_url)
+                
+                # Generate metadata
+                metadata = blog_gen.generate_metadata(blog_content, cluster_data['Primary Keyword'], cluster_data)
+                
+                # Get cover image
+                cover_image_url = blog_gen.get_cover_image(metadata['title'])
+                
+                # Create blog post data
+                blog_post_data = {
+                    'title': metadata['title'],
+                    'slug': metadata['slug'],
+                    'meta_description': metadata['meta_description'],
+                    'content': html_content,
+                    'cover_image': cover_image_url,
+                    'keywords': cluster_data['Keywords'],
+                    'primary_keyword': cluster_data['Primary Keyword'],
+                    'research': research,
+                    'detailed_plan': detailed_plan
+                }
+                
+                generated_blogs.append({
+                    'status': 'success',
+                    'message': f"Blog post generated successfully for {cluster_data['Primary Keyword']}",
+                    'data': blog_post_data
+                })
+                
+            except Exception as e:
+                logger.error(f"Error processing cluster {cluster_data['Primary Keyword']}: {e}")
+                generated_blogs.append({
+                    'status': 'error',
+                    'message': f"Failed to generate blog post for {cluster_data['Primary Keyword']}",
+                    'error': str(e)
+                })
+        
+        return jsonify({
+            'status': 'success',
+            'message': f'Generated {len(generated_blogs)} blog posts from uploaded CSV',
+            'blogs': generated_blogs
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in generate_from_csv: {e}")
+        return jsonify({'error': str(e)}), 500
+    
+
+@app.route('/generate-from-csv-text', methods=['POST'])
+def generate_from_csv_text():
+    try:
+        logger.info("Starting blog generation process for multiple clusters...")
+        
+        # Get CSV content from request JSON
+        data = request.get_json()
+        if not data or 'csv_content' not in data:
+            return jsonify({'error': 'No CSV content provided'}), 400
+            
+        csv_content = data['csv_content']
+        
+        # Initialize handlers
+        blog_gen = BlogGenerator(OPENAI_API_KEY, OPENROUTER_API_KEY)
+        csv_handler = CSVHandler()
+        
+        # Process the CSV text
+        clusters = csv_handler.process_csv_text(csv_content)
+        
+        if not clusters:
+            return jsonify({'error': 'No valid clusters found in CSV'}), 400
+            
+        generated_blogs = []
+        
+        # Process each cluster
+        for cluster_data in clusters:
+            try:
+                logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
+                
+                # Generate preliminary plan
+                logger.info("Generating preliminary plan...")
+                plan = generate_preliminary_plan(cluster_data)
+
+                # Do research
+                logger.info("Doing research...")
+                research = do_research(plan)
+
+                # Create detailed plan
+                logger.info("Creating detailed plan...")
+                detailed_plan = blog_gen.create_detailed_plan(cluster_data, plan, research)
+
+                # Write blog post
+                logger.info("Writing blog post...")
+                blog_content = blog_gen.write_blog_post(detailed_plan, cluster_data)
+
+                # Add internal links
+                logger.info("Adding internal links...")
+                previous_posts = csv_handler.get_previous_posts()
+                blog_content = blog_gen.add_internal_links(blog_content, previous_posts)
+
+                # Convert to HTML
+                logger.info("Converting to HTML...")
+                cover_image_url = blog_gen.get_cover_image(cluster_data['Primary Keyword'])
+                html_content = blog_gen.convert_to_html(blog_content, cover_image_url)
+
+                # Generate metadata
+                logger.info("Generating metadata...")
+                metadata = blog_gen.generate_metadata(blog_content, cluster_data['Primary Keyword'], cluster_data)
+
+                # Get cover image
+                logger.info("Getting cover image...")
+                cover_image_url = blog_gen.get_cover_image(metadata['title'])
+
+                blog_post_data = {
+                    'title': metadata['title'],
+                    'slug': metadata['slug'],
+                    'meta_description': metadata['meta_description'],
+                    'content': html_content,
+                    'cover_image': cover_image_url,
+                    'keywords': cluster_data['Keywords'],
+                    'primary_keyword': cluster_data['Primary Keyword'],
+                    'research': research,
+                    'detailed_plan': detailed_plan
+                }
+
+                generated_blogs.append({
+                    'status': 'success',
+                    'message': f"Blog post generated successfully for {cluster_data['Primary Keyword']}",
+                    'data': blog_post_data
+                })
+
+                csv_handler.mark_cluster_complete(cluster_data['row_number'])
+                csv_handler.log_completed_post({**metadata, 'keywords': cluster_data['Keywords']})
+
+            except Exception as e:
+                logger.error(f"Error processing cluster {cluster_data['Primary Keyword']}: {e}")
+                generated_blogs.append({
+                    'status': 'error',
+                    'message': f"Failed to generate blog post for {cluster_data['Primary Keyword']}",
+                    'error': str(e)
+                })
+
+        logger.info("All blog generation completed!")
+        return jsonify({
+            'status': 'success',
+            'message': f'Generated {len(generated_blogs)} blog posts from CSV text',
+            'blogs': generated_blogs
+        })
+
+    except Exception as e:
+        logger.error(f"Error in generate_from_csv_text: {e}")
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='127.0.0.1', port=5001, debug=True) 

blog_generator.py

@@ -0,0 +1,440 @@
+import requests
+from typing import Dict, List
+import re
+import json
+from web_scraper import get_cover_image
+
+class BlogGenerator:
+    def __init__(self, openai_key: str, openrouter_key: str, serpapi_key: str = None):
+        self.openai_key = openai_key
+        self.openrouter_key = openrouter_key
+        # serpapi_key is now optional since we're using our own image search
+
+    def get_cover_image(self, title: str) -> str:
+        """Get a cover image URL for the blog post"""
+        try:
+            # Use our custom image search function
+            image_url = get_cover_image(title)
+            if not image_url:
+                print("No image found, trying with modified query...")
+                # Try again with a more generic query if specific title fails
+                image_url = get_cover_image(title + " high quality cover image")
+            return image_url
+        except Exception as e:
+            print(f"Error in get_cover_image: {e}")
+            return None
+
+    def create_detailed_plan(self, cluster_data: Dict, preliminary_plan: str, research: str) -> str:
+        try:
+            response = requests.post(
+                'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""You are part of a team that creates world class blog posts. 
+
+For each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings, and a preliminary blog post plan. Here's a definition of each of the inputs: 
+
+- Keywords: These are the keywords which the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO. 
+
+- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post. 
+
+- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable. 
+
+- Preliminary plan: A very basic plan set out by your colleague to kick off the blog post. 
+
+- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections. 
+
+Given the above info, you must create a detailed plan for the blog post. 
+
+Your output must: 
+
+- Include a plan for the blog post.
+- Be in dot point format.
+- In each part of the blog post, you must mention which keywords should be placed. 
+- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense. 
+- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks. 
+- Your plan must satisfy the search intent and revolve directly around the given keywords. 
+- Your plan must be very detailed. 
+- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. For example, instead of saying "define X", you must have "define X as ...". 
+- The plan must have a flow that makes sense. 
+- Ensure the blog post will be highly detailed and satisfies the most important concepts regarding the topic. 
+
+A new project has just come across your desk with the following details:
+
+Keywords: {cluster_data['Keywords']}
+Primary keyword: {cluster_data['Primary Keyword']}
+Search intent: {cluster_data['Intent']}
+Preliminary plan: {preliminary_plan}
+Research findings: {research}
+
+Create the detailed plan."""
+                    }]
+                },
+                timeout=60
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"OpenRouter API error: {response.text}")
+            
+            response_data = response.json()
+            if 'choices' not in response_data:
+                raise Exception(f"Unexpected API response format: {response_data}")
+            
+            return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in create_detailed_plan: {e}")
+            raise
+
+    def write_blog_post(self, detailed_plan: str, cluster_data: Dict) -> str:
+        try:
+            response = requests.post(
+                'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""You are part of a team that creates world-class blog posts.
+
+You are the teams best copywriter and are responsible for writing out the actual blog post.
+
+For each new blog post project you are provided with a detailed plan and research findings.
+
+Your job is to create the blog post by closely following the detailed plan.
+
+The blog post you create must:
+- Follow the plan bit by bit
+- Use short paragraphs
+- Use bullet points and subheadings with keywords where appropriate
+- Not have any fluff. The content must be value dense and direct
+- Be very detailed
+- Include the keywords mentioned in each section within that section
+- Place the primary keyword in the blog title, H1 header and early in the introduction
+- Place one keyword for each section in the heading of that section
+- When possible pepper synonyms of the keywords throughout each section
+- When possible use Latent Semantic Indexing (LSI) keywords and related terms
+- Be at minimum 2000 to 2500 words long
+- Be suitable for a year 5 reading level
+
+Make sure to create the entire blog post draft in your first output. Don't stop or cut it short.
+
+Here are the details for your next blog post:
+
+Keywords: {cluster_data['Keywords']}
+Primary keyword: {cluster_data['Primary Keyword']}
+Search intent: {cluster_data['Intent']}
+Detailed plan: {detailed_plan}
+
+Write the blog post."""
+                    }]
+                },
+                timeout=120
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"OpenRouter API error: {response.text}")
+            
+            response_data = response.json()
+            if 'choices' not in response_data:
+                raise Exception(f"Unexpected API response format: {response_data}")
+            
+            return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in write_blog_post: {e}")
+            raise
+
+    def add_internal_links(self, blog_content: str, previous_posts: List[Dict]) -> str:
+        try:
+            response = requests.post(
+                # 'https://api.openai.com/v1/chat/completions',
+                # headers={
+                #     'Authorization': f'Bearer {self.openai_key}',
+                #     'Content-Type': 'application/json'
+                # },
+                # json={
+                #     'model': 'gpt-4',
+                  'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""You are part of a team that creates world class blog posts.
+
+You are in charge of internal linking between blog posts.
+
+For each new blog post that comes across your desk, your job is to look through previously posted blogs and make at least 5 internal links.
+
+To choose the best internal linking opportunities you must:
+- Read the previous blog post summaries and look through their keywords. If there is a match where the previous blog post is highly relevant, then this is an internal linking opportunity.
+- Do not link if it is not highly relevant. Only make a link if it makes sense and adds value for the reader.
+
+Once you've found the best linking opportunities, you must update the blog post with the internal links. To do this you must:
+- Add the link of the previous blog post at the relevant section of the new blog post. Drop the URL at the place which makes most sense. Later we will hyperlink the URL to the word in the blog post which it is placed next to. So your placing is very important.
+
+Make sure to:
+- Not delete any existing URLs or change anything about the blog post
+- Only add new internal linking URLs
+- Place URLs next to relevant anchor text
+- Add at least 5 internal links if possible
+- Only link when truly relevant and valuable
+- Preserve all original content and formatting
+
+Current blog post:
+{blog_content}
+
+Previous blog posts:
+{json.dumps(previous_posts, indent=2)}
+
+Your output must be the complete blog post with new internal links added. Don't summarize or modify the content - just add the URLs in appropriate places."""
+                    }]
+                },
+                timeout=120
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"OpenAI API error: {response.text}")
+            
+            response_data = response.json()
+            if 'choices' not in response_data:
+                raise Exception(f"Unexpected API response format: {response_data}")
+            
+            return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in add_internal_links: {e}")
+            # If there's an error, return the original content
+            return blog_content
+
+    def convert_to_html(self, blog_content: str, image_url: str = None) -> str:
+        try:
+            # First replace newlines with <br> tags
+            formatted_content = blog_content.replace('\n', '<br>')
+            
+            # Add image URL to the prompt
+            image_instruction = ""
+            if image_url:
+                image_instruction = f"Add this image at the top of the post after the title: {image_url}"
+            
+            response = requests.post(
+                # 'https://api.openai.com/v1/chat/completions',
+                # headers={
+                #     'Authorization': f'Bearer {self.openai_key}',
+                #     'Content-Type': 'application/json'
+                # },
+                # json={
+                #     'model': 'anthropic/claude-3.5-sonnet:beta',
+                  'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""DO NOT OUTPUT ANYTHING OTHER THAN THE HTML CODE. Follow this layout template to generate WordPress code for a blog post:
+
+The blog post should have:
+- Title
+{f"- Featured image: <img src='{image_url}' alt='Featured image' style='width: 100%; height: auto; margin: 20px 0;'>" if image_url else ""}
+- Estimated reading time 
+- Key takeaways
+- Table of contents
+- Body
+- FAQ
+
+Rules:
+- Make it engaging using italics, dot points, quotes, bold, spaces, and new lines. No emojis.
+- Hyperlink any referenced URLs to their adjacent keyphrases
+- Wrap content in container <div> with inline CSS for white text (#000000), Arial/sans-serif font, 1.6 line height
+- Set non-heading text to 20px and white (#000000) with !important
+- Style links, TOC points, and FAQ questions in blue (#00c2ff)
+- Add blue (#00c2ff) underline border to headings with padding
+- Add double breaks (<br>) between sections
+- Output only the HTML code, no extra text
+
+Blog post content:
+{formatted_content}"""
+                    }]
+                },
+                timeout=120
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"OpenAI API error: {response.text}")
+            
+            response_data = response.json()
+            if 'choices' not in response_data:
+                raise Exception(f"Unexpected API response format: {response_data}")
+            blog_content1 = response_data['choices'][0]['message']['content']
+            formatted_content1 = blog_content1.replace('\n', '')
+            return formatted_content1
+        except Exception as e:
+            print(f"Error in convert_to_html: {e}")
+            # If there's an error, return the original content
+            return blog_content
+
+    def generate_metadata(self, blog_content: str, primary_keyword: str, cluster_data: Dict) -> Dict:
+        try:
+            # Generate slug
+            slug_response = requests.post(
+                # 'https://api.openai.com/v1/chat/completions',
+                # headers={
+                #     'Authorization': f'Bearer {self.openai_key}',
+                #     'Content-Type': 'application/json'
+                # },
+                # json={
+                #     'model': 'gpt-4',
+                  'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""Create a slug for the following blog post:
+
+{blog_content}
+
+A slug in a blog post is the part of the URL that comes after the domain name and identifies a specific page. It is typically a short, descriptive phrase that summarizes the content of the post, making it easier for users and search engines to understand what the page is about. For example, in the URL www.example.com/intelligent-agents, the slug is intelligent-agents. A good slug is concise, contains relevant keywords, and avoids unnecessary words to improve readability and SEO.
+
+The slug must be 4 or 5 words max and must include the primary keyword of the blog post which is {primary_keyword}.
+
+Your output must be the slug and nothing else so that I can copy and paste your output and put it at the end of my blog post URL to post it right away."""
+                    }]
+                },
+                timeout=60
+            )
+            
+            if slug_response.status_code != 200:
+                raise Exception(f"OpenAI API error: {slug_response.text}")
+            
+            slug_data = slug_response.json()
+            if 'choices' not in slug_data:
+                raise Exception(f"Unexpected API response format: {slug_data}")
+            
+            slug = slug_data['choices'][0]['message']['content'].strip().lower()
+
+            # Generate title
+            title_response = requests.post(
+                # 'https://api.openai.com/v1/chat/completions',
+                # headers={
+                #     'Authorization': f'Bearer {self.openai_key}',
+                #     'Content-Type': 'application/json'
+                # },
+                # json={
+                #     'model': 'gpt-4',
+                  'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""Extract the blog post title from the following blog post:
+
+{blog_content}
+
+The blog post title must include the primary keyword {primary_keyword} and must inform the users right away of what they can expect from reading the blog post.
+
+- Don't put the output in "". The output should just text with no markdown or formatting.
+
+Your output must only be the blog post title and nothing else."""
+                    }]
+                },
+                timeout=60
+            )
+            
+            if title_response.status_code != 200:
+                raise Exception(f"OpenAI API error: {title_response.text}")
+            
+            title_data = title_response.json()
+            if 'choices' not in title_data:
+                raise Exception(f"Unexpected API response format: {title_data}")
+            
+            title = title_data['choices'][0]['message']['content'].strip()
+
+            # Generate meta description
+            meta_desc_response = requests.post(
+                # 'https://api.openai.com/v1/chat/completions',
+                # headers={
+                #     'Authorization': f'Bearer {self.openai_key}',
+                #     'Content-Type': 'application/json'
+                # },
+                # json={
+                #     'model': 'gpt-4',
+                  'https://openrouter.ai/api/v1/chat/completions',
+                headers={
+                    'Authorization': f'Bearer {self.openrouter_key}',
+                    'HTTP-Referer': 'http://localhost:5001',
+                    'X-Title': 'Blog Generator'
+                },
+                json={
+                    'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"""Create a proper meta description for the following blog post:
+
+{blog_content}
+
+A good meta description for a blog post that is SEO-optimized should:
+- Be Concise: Stick to 150-160 characters to ensure the full description displays in search results.
+- Include Keywords: Incorporate primary keywords naturally to improve visibility and relevance to search queries.
+
+Primary keyword = {primary_keyword}
+
+More keywords to include if possible = [{cluster_data['Keywords']}]
+
+- Provide Value: Clearly describe what the reader will learn or gain by clicking the link.
+- Be Engaging: Use persuasive language, such as action verbs or a question, to encourage clicks.
+- Align with Content: Ensure the description accurately reflects the blog post to meet user expectations and reduce bounce rates.
+
+Your output must only be the meta description and nothing else."""
+                    }]
+                },
+                timeout=60
+            )
+            
+            if meta_desc_response.status_code != 200:
+                raise Exception(f"OpenAI API error: {meta_desc_response.text}")
+            
+            meta_desc_data = meta_desc_response.json()
+            if 'choices' not in meta_desc_data:
+                raise Exception(f"Unexpected API response format: {meta_desc_data}")
+            
+            meta_desc = meta_desc_data['choices'][0]['message']['content'].strip()
+
+            # Validate the results
+            if not title or not meta_desc or not slug:
+                raise Exception("Empty title, meta description, or slug")
+
+            return {
+                'slug': slug,
+                'title': title,
+                'meta_description': meta_desc
+            }
+        except Exception as e:
+            print(f"Error in generate_metadata: {e}")
+            raise 

clusters.csv

@@ -0,0 +1,2 @@
+Cluster,Keywords,Intent,Primary Keyword,Status
+1,Maniya Sri Lankan Streamer," Maniya Streams youtube channel""",Manitha Abeysiriwardana,completed,Maniya Streams,yes

completed_posts.csv

@@ -0,0 +1,4 @@
+Title,Keywords,Meta Description,URL
+Discovering Nanobotz IT Solutions: Your Detailed Guide,"Nanobotz it solutions company, nanobotz it solutions company details","Discover Nanobotz IT Solutions: Your detailed guide to this Sri Lankan IT company's services, expertise & see if they are the right IT partner for your business.",https://yourblog.com/nanobotz-it-solutions-guide
+Unveiling Nanobotz IT Solutions: Your Comprehensive Guide to the Company and its Services,"Nanobotz it solutions company, nanobotz it solutions company details","Discover Nanobotz IT Solutions, a comprehensive IT solutions company. Learn about their services, expertise & see if they are the right partner for you.",https://yourblog.com/nanobotz-it-solutions-company-guide
+"Discover ""Maniya Streams"": Your Gateway to Engaging Content by Sri Lankan Streamer Manitha Abeysiriwardana",Maniya Sri Lankan Streamer,Discover Maniya Streams! Your gateway to engaging content by Sri Lankan streamer Manitha Abeysiriwardana. Learn about her YouTube channel and videos now!,https://yourblog.com/manitha-abeysiriwardana-maniya-streams

create_csv_files.py

@@ -0,0 +1,20 @@
+import csv
+
+def create_clusters_csv():
+    """Create the initial clusters.csv file with proper headers"""
+    with open('clusters.csv', 'w', newline='', encoding='utf-8') as file:
+        writer = csv.writer(file)
+        writer.writerow(['Keywords', 'Intent', 'Primary Keyword', 'Status'])
+
+# Create clusters.csv
+with open('clusters.csv', 'w', newline='') as file:
+    writer = csv.writer(file)
+    writer.writerow(['Cluster', 'Keywords', 'Intent', 'Primary Keyword', 'Status'])
+    # Add some sample data
+    # writer.writerow(['1', 'ai tools, business productivity, automation', 'Learn about AI tools', 'ai tools for business', 'no'])
+    writer.writerow(['2', 'Nanobotz it solutions company, nanobotz it solutions company details', 'nanobotz it solutions', 'nanobotz it solutions', 'no'])
+
+# Create completed_posts.csv
+with open('completed_posts.csv', 'w', newline='') as file:
+    writer = csv.writer(file)
+    writer.writerow(['Title', 'Keywords', 'Meta Description', 'URL']) 

credentials.json

@@ -0,0 +1,14 @@
+{
+    "installed": {
+        "client_id": "184835172690-4da6h3la4rovieickngacl4ec9n5g4j9.apps.googleusercontent.com",
+        "project_id": "silver-shift-424412-a8",
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+        "client_secret": "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",
+        "redirect_uris": [
+            "http://localhost:5001",
+            "http://127.0.0.1:5001"
+        ]
+    }
+} 

csv_handler.py

@@ -0,0 +1,196 @@
+import csv
+from typing import Dict, List
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+class CSVHandler:
+    def __init__(self):
+        self.clusters_file = 'clusters.csv'
+        self.completed_posts_file = 'completed_posts.csv'
+
+    def get_cluster_data(self) -> Dict:
+        try:
+            with open(self.clusters_file, 'r', newline='') as file:
+                reader = csv.DictReader(file)
+                for i, row in enumerate(reader, start=2):  # start=2 because row 1 is header
+                    if row['Status'].lower() == 'no':
+                        return {
+                            'Keywords': row['Keywords'],
+                            'Intent': row['Intent'],
+                            'Primary Keyword': row['Primary Keyword'],
+                            'row_number': i
+                        }
+            return None
+        except Exception as e:
+            print(f"Error reading clusters CSV: {e}")
+            return None
+
+    def get_previous_posts(self) -> List[Dict]:
+        try:
+            posts = []
+            with open(self.completed_posts_file, 'r', newline='') as file:
+                reader = csv.DictReader(file)
+                for row in reader:
+                    posts.append({
+                        'title': row['Title'],
+                        'keywords': row['Keywords'],
+                        'summary': row['Meta Description'],
+                        'url': row['URL']
+                    })
+            return posts
+        except Exception as e:
+            print(f"Error reading completed posts CSV: {e}")
+            return []
+
+    def mark_cluster_complete(self, row_number: int):
+        try:
+            # Read all rows
+            rows = []
+            with open(self.clusters_file, 'r', newline='', encoding='utf-8') as file:
+                reader = csv.reader(file)
+                header = next(reader)  # Get header row
+                
+                # Find Status column index, default to last column if not found
+                status_index = header.index('Status') if 'Status' in header else -1
+                if status_index == -1:
+                    header.append('Status')
+                    status_index = len(header) - 1
+                
+                rows = [header]
+                rows.extend(list(reader))
+
+            # Update status to 'completed' for the specified row
+            if row_number < len(rows):
+                # Ensure row has enough columns
+                while len(rows[row_number]) <= status_index:
+                    rows[row_number].append('')
+                rows[row_number][status_index] = 'completed'
+
+            # Write back all rows
+            with open(self.clusters_file, 'w', newline='', encoding='utf-8') as file:
+                writer = csv.writer(file)
+                writer.writerows(rows)
+
+        except Exception as e:
+            logger.error(f"Error updating cluster status: {e}")
+            raise
+
+    def log_completed_post(self, metadata: Dict):
+        try:
+            with open(self.completed_posts_file, 'a', newline='') as file:
+                writer = csv.writer(file)
+                writer.writerow([
+                    metadata['title'],
+                    metadata['keywords'],
+                    metadata['meta_description'],
+                    f"https://yourblog.com/{metadata['slug']}"
+                ])
+        except Exception as e:
+            print(f"Error logging completed post: {e}")
+
+    def get_all_clusters(self):
+        """Get all uncompleted clusters from the CSV file."""
+        clusters = []
+        try:
+            with open(self.clusters_file, 'r', newline='', encoding='utf-8') as file:
+                reader = csv.DictReader(file)
+                for row_number, row in enumerate(reader, start=1):
+                    # Check if Status column exists, if not or empty, treat as not completed
+                    status = row.get('Status', '').lower()
+                    if status != 'completed':
+                        cluster_data = {
+                            'Keywords': row.get('Keywords', ''),
+                            'Intent': row.get('Intent', ''),
+                            'Primary Keyword': row.get('Primary Keyword', ''),
+                            'row_number': row_number,
+                            'Status': status
+                        }
+                        # Validate required fields
+                        if all(cluster_data[field] for field in ['Keywords', 'Intent', 'Primary Keyword']):
+                            clusters.append(cluster_data)
+                        else:
+                            logger.warning(f"Row {row_number}: Missing required fields, skipping")
+                return clusters
+        except Exception as e:
+            logger.error(f"Error reading clusters file: {e}")
+            raise
+
+    def process_uploaded_csv(self, csv_content: str) -> List[Dict]:
+        """
+        Process an uploaded CSV content string and return cluster data for blog generation.
+        
+        Args:
+            csv_content (str): The decoded CSV content as a string
+            
+        Returns:
+            List[Dict]: List of cluster data dictionaries
+        """
+        clusters = []
+        try:
+            # Split the content into lines and process as CSV
+            from io import StringIO
+            csv_file = StringIO(csv_content)
+            reader = csv.DictReader(csv_file)
+            
+            for row_number, row in enumerate(reader, start=1):
+                # Validate required columns
+                required_columns = ['Keywords', 'Intent', 'Primary Keyword']
+                if not all(col in row for col in required_columns):
+                    logger.error(f"Row {row_number}: Missing required columns. Required: {required_columns}")
+                    continue
+                    
+                cluster_data = {
+                    'Keywords': row['Keywords'],
+                    'Intent': row['Intent'],
+                    'Primary Keyword': row['Primary Keyword'],
+                    'row_number': row_number
+                }
+                clusters.append(cluster_data)
+                
+            logger.info(f"Successfully processed {len(clusters)} clusters from uploaded CSV")
+            return clusters
+            
+        except Exception as e:
+            logger.error(f"Error processing uploaded CSV: {e}")
+            raise
+
+    def process_csv_text(self, csv_text: str) -> List[Dict]:
+        """
+        Process CSV content provided as a text string and return cluster data for blog generation.
+        
+        Args:
+            csv_text (str): The CSV content as a string
+            
+        Returns:
+            List[Dict]: List of cluster data dictionaries
+        """
+        clusters = []
+        try:
+            # Split the text into lines
+            from io import StringIO
+            csv_file = StringIO(csv_text.strip())
+            reader = csv.DictReader(csv_file)
+            
+            for row_number, row in enumerate(reader, start=1):
+                # Validate required columns
+                required_columns = ['Keywords', 'Intent', 'Primary Keyword']
+                if not all(col in row for col in required_columns):
+                    logger.error(f"Row {row_number}: Missing required columns. Required: {required_columns}")
+                    continue
+                    
+                cluster_data = {
+                    'Keywords': row['Keywords'],
+                    'Intent': row['Intent'],
+                    'Primary Keyword': row['Primary Keyword'],
+                    'row_number': row_number
+                }
+                clusters.append(cluster_data)
+                
+            logger.info(f"Successfully processed {len(clusters)} clusters from CSV text")
+            return clusters
+            
+        except Exception as e:
+            logger.error(f"Error processing CSV text: {e}")
+            raise 

output.json

@@ -0,0 +1,3 @@
+[
+
+]

phone_location_tracker.py

@@ -0,0 +1,58 @@
+import phonenumbers
+from phonenumbers import geocoder, carrier, timezone
+
+def track_phone_location(phone_number):
+    try:
+        # Parse the phone number
+        parsed_number = phonenumbers.parse(phone_number)
+        
+        # Get location information
+        country = geocoder.description_for_number(parsed_number, "en")
+        
+        # Get carrier information
+        service_provider = carrier.name_for_number(parsed_number, "en")
+        
+        # Get timezone information
+        time_zones = timezone.time_zones_for_number(parsed_number)
+        
+        # Check if the number is valid
+        is_valid = phonenumbers.is_valid_number(parsed_number)
+        
+        return {
+            "phone_number": phone_number,
+            "country": country,
+            "service_provider": service_provider,
+            "time_zones": list(time_zones),
+            "is_valid": is_valid
+        }
+    
+    except Exception as e:
+        return {
+            "error": str(e),
+            "phone_number": phone_number
+        }
+
+def main():
+    while True:
+        print("\nPhone Number Location Tracker")
+        print("----------------------------")
+        phone_number = input("Enter phone number (with country code, e.g., +1234567890) or 'q' to quit: ")
+        
+        if phone_number.lower() == 'q':
+            print("Goodbye!")
+            break
+            
+        result = track_phone_location(phone_number)
+        
+        if "error" in result:
+            print(f"\nError: {result['error']}")
+        else:
+            print("\nResults:")
+            print(f"Phone Number: {result['phone_number']}")
+            print(f"Country: {result['country']}")
+            print(f"Service Provider: {result['service_provider']}")
+            print(f"Time Zones: {', '.join(result['time_zones'])}")
+            print(f"Valid Number: {'Yes' if result['is_valid'] else 'No'}")
+
+if __name__ == "__main__":
+    main() 

requirements.txt

@@ -0,0 +1,7 @@
+flask==3.0.0
+python-dotenv==1.0.0
+requests==2.31.0
+beautifulsoup4==4.12.2
+python-slugify==8.0.1
+logging==0.4.9.6
+typing==3.7.4.3 

sheets_handler.py

@@ -0,0 +1,91 @@
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+import os.path
+import pickle
+from typing import Dict
+
+class SheetsHandler:
+    def __init__(self, credentials_path: str):
+        self.SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
+        self.creds = None
+        
+        # Load existing token if it exists
+        if os.path.exists('token.pickle'):
+            with open('token.pickle', 'rb') as token:
+                self.creds = pickle.load(token)
+        
+        # If no valid credentials available, let user log in
+        if not self.creds or not self.creds.valid:
+            if self.creds and self.creds.expired and self.creds.refresh_token:
+                self.creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(
+                    credentials_path, self.SCOPES)
+                self.creds = flow.run_local_server(
+                    port=8085,
+                    success_message='The authentication flow has completed. You may close this window.',
+                    open_browser=True
+                )
+            
+            # Save the credentials for the next run
+            with open('token.pickle', 'wb') as token:
+                pickle.dump(self.creds, token)
+
+        self.service = build('sheets', 'v4', credentials=self.creds)
+
+    def get_previous_posts(self):
+        # Implementation for getting previous posts
+        try:
+            result = self.service.spreadsheets().values().get(
+                spreadsheetId='1CL0L4V288SEygm0BieMRM8t8h7MbcV9bYyzkDc0zInU',
+                range='Sheet1!A:D'
+            ).execute()
+            rows = result.get('values', [])
+            if not rows:
+                return []
+            
+            posts = []
+            for row in rows[1:]:  # Skip header
+                if len(row) >= 4:
+                    posts.append({
+                        'title': row[0],
+                        'keywords': row[1],
+                        'summary': row[2],
+                        'url': row[3]
+                    })
+            return posts
+        except Exception as e:
+            print(f"Error getting previous posts: {e}")
+            return []
+
+    def mark_cluster_complete(self, sheet_id: str, sheet_name: str, row_number: int):
+        range_name = f"{sheet_name}!E{row_number}"
+        body = {
+            'values': [['yes']]
+        }
+        self.service.spreadsheets().values().update(
+            spreadsheetId=sheet_id,
+            range=range_name,
+            valueInputOption='RAW',
+            body=body
+        ).execute()
+
+    def log_completed_post(self, sheet_id: str, metadata: Dict):
+        range_name = 'Sheet1!A:D'
+        body = {
+            'values': [[
+                metadata['title'],
+                metadata['keywords'],
+                metadata['meta_description'],
+                f"https://yourblog.com/{metadata['slug']}"
+            ]]
+        }
+        self.service.spreadsheets().values().append(
+            spreadsheetId=sheet_id,
+            range=range_name,
+            valueInputOption='RAW',
+            insertDataOption='INSERT_ROWS',
+            body=body
+        ).execute() 

test_api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+
+def test_blog_generation():
+    try:
+        # Add timeout of 300 seconds (5 minutes)
+        response = requests.post('http://localhost:5001/generate-blog', timeout=300)
+        
+        if response.status_code == 200:
+            data = response.json()
+            print("Blog Generation Successful!")
+            print("\nTitle:", data['data']['title'])
+            print("\nSlug:", data['data']['slug'])
+            print("\nMeta Description:", data['data']['meta_description'])
+            print("\nKeywords:", data['data']['keywords'])
+            print("\nPrimary Keyword:", data['data']['primary_keyword'])
+            print("\nCover Image URL:", data['data']['cover_image'])
+            print("\nDetailed Plan:", data['data']['detailed_plan'])
+            print("\nResearch:", data['data']['research'])
+            print("\nContent Preview:", data['data']['content'][:500] + "...")
+        else:
+            print("Error:", response.json()['error'])
+    except requests.exceptions.Timeout:
+        print("Request timed out after 5 minutes")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    test_blog_generation() 

testt.py

@@ -0,0 +1,38 @@
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+def start_requests(self):
+    query = input("Enter your search query: ")
+    google_search_url = f"https://www.google.com/search?q={query}"
+
+    # Set up Selenium
+    options = webdriver.ChromeOptions()
+    options.add_argument('--headless')  # Run in headless mode
+    options.add_argument('--disable-gpu')
+    options.add_argument('--no-sandbox')
+    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
+
+    driver.get(google_search_url)
+    soup = BeautifulSoup(driver.page_source, 'html.parser')
+    driver.quit()
+
+    urls = []
+    for link in soup.find_all('a', href=True):
+        href = link['href']
+        if href.startswith('/url?q='):
+            url = href.split('/url?q=')[1].split('&')[0]
+            if not url.startswith('http'):
+                continue
+            urls.append(url)
+            if len(urls) == self.max_scrapes:
+                break
+
+    if not urls:
+        self.logger.error("No URLs extracted from Google search results.")
+        return
+
+    self.logger.info(f"Extracted URLs: {urls}")
+    for url in urls:
+        yield Request(url, callback=self.parse)

web_scraper.py

@@ -0,0 +1,377 @@
+from flask import Flask, jsonify, request
+import requests
+from bs4 import BeautifulSoup
+import os
+import re
+import urllib.parse
+import time
+import random
+import base64
+from io import BytesIO
+from googlesearch import search
+import json
+
+app = Flask(__name__)
+
+def search_images(query, num_images=5):
+    # Headers to mimic a browser request
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Accept-Encoding': 'gzip, deflate',
+        'DNT': '1',
+        'Connection': 'keep-alive',
+    }
+
+    # Format the query for URL
+    formatted_query = urllib.parse.quote(query + " high quality")
+
+    # Google Images URL
+    url = f"https://www.google.com/search?q={formatted_query}&tbm=isch&safe=active"
+
+    try:
+        # Get the HTML content
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+
+        # Find all image URLs using regex
+        image_urls = re.findall(r'https?://[^"\']*?(?:jpg|jpeg|png|gif)', response.text)
+
+        # Remove duplicates while preserving order
+        image_urls = list(dict.fromkeys(image_urls))
+
+        # Filter and clean results
+        results = []
+        for img_url in image_urls:
+            if len(results) >= num_images:
+                break
+
+            # Skip small thumbnails, icons, and low-quality images
+            if ('gstatic.com' in img_url or 
+                'google.com' in img_url or 
+                'icon' in img_url.lower() or 
+                'thumb' in img_url.lower() or
+                'small' in img_url.lower()):
+                continue
+
+            try:
+                # Verify the image URL is valid
+                img_response = requests.head(img_url, headers=headers, timeout=5)
+                if img_response.status_code == 200:
+                    content_type = img_response.headers.get('Content-Type', '')
+                    if content_type.startswith('image/'):
+                        results.append({
+                            'url': img_url,
+                            'content_type': content_type
+                        })
+
+            except Exception as e:
+                print(f"Error checking image URL: {str(e)}")
+                continue
+
+            # Add a small delay between checks
+            time.sleep(random.uniform(0.2, 0.5))
+
+        return results
+
+    except Exception as e:
+        print(f"An error occurred: {str(e)}")
+        return []
+
+def get_cover_image(query):
+    """Get a high-quality cover image URL for a given query"""
+    try:
+        # Search for images
+        images = search_images(query, num_images=3)  # Get top 3 images to choose from
+        
+        if not images:
+            return None
+            
+        # Return the first valid image URL
+        return images[0]['url']
+        
+    except Exception as e:
+        print(f"Error getting cover image: {str(e)}")
+        return None
+
+@app.route('/search_images', methods=['GET'])
+def api_search_images():
+    try:
+        # Get query parameters
+        query = request.args.get('query', '')
+        num_images = int(request.args.get('num_images', 5))
+
+        if not query:
+            return jsonify({'error': 'Query parameter is required'}), 400
+
+        if num_images < 1 or num_images > 20:
+            return jsonify({'error': 'Number of images must be between 1 and 20'}), 400
+
+        # Search for images
+        results = search_images(query, num_images)
+
+        return jsonify({
+            'success': True,
+            'query': query,
+            'results': results
+        })
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+def scrape_site_content(query, num_sites=5):
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Accept-Encoding': 'gzip, deflate',
+        'DNT': '1',
+        'Connection': 'keep-alive',
+    }
+
+    results = []
+    scraped = 0
+    retries = 2  # Number of retries per URL
+    timeout = 5  # Reduced timeout to 5 seconds
+
+    try:
+        # Get more URLs than needed to account for failures
+        search_results = list(search(query, num_results=num_sites * 2))
+        
+        # Process each found URL
+        for url in search_results:
+            if scraped >= num_sites:
+                break
+
+            success = False
+            for attempt in range(retries):
+                try:
+                    # Get the HTML content
+                    print(f"Trying {url} (attempt {attempt + 1}/{retries})")
+                    response = requests.get(
+                        url, 
+                        headers=headers, 
+                        timeout=timeout,
+                        verify=False  # Skip SSL verification
+                    )
+                    response.raise_for_status()
+
+                    # Verify it's HTML content
+                    content_type = response.headers.get('Content-Type', '').lower()
+                    if 'text/html' not in content_type:
+                        print(f"Skipping {url} - not HTML content")
+                        break
+
+                    # Parse the HTML content
+                    soup = BeautifulSoup(response.text, 'html.parser')
+
+                    # Remove script and style elements
+                    for script in soup(["script", "style"]):
+                        script.decompose()
+
+                    # Extract text content (limit to first 10000 characters)
+                    text_content = soup.get_text(separator='\n', strip=True)[:10000]
+                    
+                    # Skip if not enough content
+                    if len(text_content.split()) < 100:  # Skip if less than 100 words
+                        print(f"Skipping {url} - not enough content")
+                        break
+
+                    # Extract all links (limit to first 10)
+                    links = []
+                    for link in soup.find_all('a', href=True)[:10]:
+                        href = link['href']
+                        if href.startswith('http'):
+                            links.append({
+                                'text': link.get_text(strip=True),
+                                'url': href
+                            })
+
+                    # Extract meta information
+                    title = soup.title.string if soup.title else ''
+                    meta_description = ''
+                    meta_keywords = ''
+
+                    meta_desc_tag = soup.find('meta', attrs={'name': 'description'})
+                    if meta_desc_tag:
+                        meta_description = meta_desc_tag.get('content', '')
+
+                    meta_keywords_tag = soup.find('meta', attrs={'name': 'keywords'})
+                    if meta_keywords_tag:
+                        meta_keywords = meta_keywords_tag.get('content', '')
+
+                    results.append({
+                        'url': url,
+                        'title': title,
+                        'meta_description': meta_description,
+                        'meta_keywords': meta_keywords,
+                        'text_content': text_content,
+                        'links': links
+                    })
+
+                    scraped += 1
+                    success = True
+                    # Add a random delay between scrapes
+                    time.sleep(random.uniform(0.5, 1))
+                    break  # Break retry loop on success
+
+                except requests.Timeout:
+                    print(f"Timeout on {url} (attempt {attempt + 1}/{retries})")
+                    if attempt == retries - 1:  # Last attempt
+                        print(f"Skipping {url} after {retries} timeout attempts")
+                except requests.RequestException as e:
+                    print(f"Error scraping {url} (attempt {attempt + 1}/{retries}): {str(e)}")
+                    if attempt == retries - 1:  # Last attempt
+                        print(f"Skipping {url} after {retries} failed attempts")
+                
+                # Add a longer delay between retries
+                if not success and attempt < retries - 1:
+                    time.sleep(random.uniform(1, 2))
+
+            # If we haven't found enough valid content and have more URLs, continue
+            if scraped < num_sites and len(results) < len(search_results):
+                continue
+
+        return results
+
+    except Exception as e:
+        print(f"Error in search/scraping process: {str(e)}")
+        # Return whatever results we've managed to gather
+        return results
+
+@app.route('/scrape_sites', methods=['GET'])
+def api_scrape_sites():
+    try:
+        # Get query parameters
+        query = request.args.get('query', '')
+        num_sites = int(request.args.get('num_sites', 10))
+
+        if not query:
+            return jsonify({'error': 'Query parameter is required'}), 400
+
+        if num_sites < 1 or num_sites > 20:
+            return jsonify({'error': 'Number of sites must be between 1 and 20'}), 400
+
+        # Scrape the websites
+        results = scrape_site_content(query, num_sites)
+
+        return jsonify({
+            'success': True,
+            'query': query,
+            'results': results
+        })
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+def analyze_with_gpt(scraped_content, research_query):
+    """Analyze scraped content using OpenRouter's Gemini model"""
+    try:
+        headers = {
+            'Authorization': f'Bearer {os.getenv("OPENROUTER_API_KEY")}',
+            'HTTP-Referer': 'http://localhost:5001',
+            'X-Title': 'Research Assistant'
+        }
+
+        # Prepare the prompt
+        prompt = f"""You are a research assistant analyzing web content to provide comprehensive research.
+
+Research Query: {research_query}
+
+Below is content scraped from various web sources. Analyze this content and provide a detailed, well-structured research response.
+Make sure to cite sources when making specific claims.
+
+Scraped Content:
+{json.dumps(scraped_content, indent=2)}
+
+Please provide:
+1. A comprehensive analysis of the topic
+2. Key findings and insights
+3. Supporting evidence from the sources
+4. Any additional considerations or caveats
+
+Format your response in markdown with proper headings and citations."""
+
+        response = requests.post(
+            'https://openrouter.ai/api/v1/chat/completions',
+            headers=headers,
+            json={
+                'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                'messages': [{
+                    'role': 'user',
+                    'content': prompt
+                }]
+            },
+            timeout=60
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"OpenRouter API error: {response.text}")
+
+        return response.json()['choices'][0]['message']['content']
+    except Exception as e:
+        print(f"Error in analyze_with_gpt: {str(e)}")
+        return f"Error analyzing content: {str(e)}"
+
+def research_topic(query, num_sites=5):
+    """Research a topic using web scraping and GPT analysis"""
+    try:
+        # First get web content using existing scrape_site_content function
+        scraped_results = scrape_site_content(query, num_sites)
+        
+        # Format scraped content for analysis
+        formatted_content = []
+        for result in scraped_results:
+            formatted_content.append({
+                'source': result['url'],
+                'title': result['title'],
+                'content': result['text_content'][:2000],  # Limit content length for GPT
+                'meta_info': {
+                    'description': result['meta_description'],
+                    'keywords': result['meta_keywords']
+                }
+            })
+        
+        # Get AI analysis of the scraped content
+        analysis = analyze_with_gpt(formatted_content, query)
+        
+        return {
+            'success': True,
+            'query': query,
+            'analysis': analysis,
+            'sources': formatted_content
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+@app.route('/research', methods=['GET'])
+def api_research():
+    try:
+        query = request.args.get('query', '')
+        # Always use 5 sites for consistency
+        num_sites = 5
+
+        if not query:
+            return jsonify({'error': 'Query parameter is required'}), 400
+
+        results = research_topic(query, num_sites)
+        return jsonify(results)
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)

wordpress_handler.py

@@ -0,0 +1,26 @@
+from wordpress_xmlrpc import Client, WordPressPost
+from wordpress_xmlrpc.methods.posts import NewPost
+from typing import Dict
+
+class WordPressHandler:
+    def __init__(self, url: str, username: str, password: str):
+        self.client = Client(url, username, password)
+
+    def publish_post(self, content: str, metadata: Dict, image_url: str) -> int:
+        post = WordPressPost()
+        post.title = metadata['title']
+        post.content = f'<img src="{image_url}" alt="Cover Image">\n{content}'
+        post.slug = metadata['slug']
+        post.post_status = 'draft'
+        post.terms_names = {
+            'category': ['Your Category'],
+            'post_tag': ['Your Tags']
+        }
+        post.custom_fields = []
+        post.custom_fields.append({
+            'key': '_yoast_wpseo_metadesc',
+            'value': metadata['meta_description']
+        })
+
+        post_id = self.client.call(NewPost(post))
+        return post_id