Cara Menggunakan ChatGPT Untuk Mendominasi Dalam SEO

Hari ini kita berbicara mengenai SEO dan bagaimana sepenuhnya memparadigma game SEO memakai Chat GPT API dan beberapa pengkodean kreatif. Tetapi pertama-tama, silahkan kita percepat cara kerja SEO saat ini, dan kenapa membuat beberapa ratus artikel tiap hari kemungkinan besar ialah tujuan kita.

SEO atau Search Engine Optimization ialah praktik membuat website Anda lebih menarik untuk Mesin Pencari sehingga Anda mulai mendapat peringkat lebih tinggi di niche khusus Anda.

Apa itu Data Website Inti

Google khususnya akan mempertimbangkan suatu hal yang disebut Core Web Vitals.

Core Web Vitals ialah kumpulan metrik performa situs tertentu yang sudah diidentifikasi Google sebagai hal yang penting untuk memberikan pengalaman pengguna yang baik. Mereka konsentrasi pada tiga bidang khusus performa website: loading speed, interaktivitas, dan stabilitas visual.

Largest Contentful Paint (LCP) — mengukur performa loading. Ini melacak waktu yang diperlukan content element terbesar di viewport (seperti gambar atau block text) untuk dirender di layar.
First Input Delay (FID) — mengukur interaktivitas. Ini melacak waktu yang dibutuhkan pengguna untuk bisa berinteraksi dengan website, seperti mengklik tombol atau link, setelah halaman selesai dimuat.
Cumulative Layout Shift (CLS) — mengukur kestabilan visual. Ini melacak jumlah perubahan tata letak tak terduga yang terjadi selama proses pemuatan. Misalkan, saat elemen di halaman tiba-tiba bergerak, mengakibatkan pengguna tidak sengaja mengeklik tombol yang salah.

Google menjadikan inti website vitals sebagai factor peringkat semenjak Mei 2021, jadi jika Anda melihat semakin banyak website yang feeling/looking sama, Anda dapat menyalahkan Google untuk tersebut.

Tapi bahkan dengan Core website vitals yang diperhitungkan dalam SEO Anda — content masih jadi raja, dan ya Tuhan, Google menyukainya. Obsesi Mesin Pencari dengan content mengubah setiap website di luar sana menjadi content house, fokus pada menghasilkan sebanyak mungkin SEO-friendly articles . Kuantitas melebihi Kualitas menang setiap saat (asalkan itu unik).

Dan itu membawa kita ke topik hari ini — cara menggunakan ChatGPT untuk membuat unique content. Anda memerlukan beberapa pengetahuan tentang python untuk menyiapkan ini, tapi saya akan membawa Anda melalui seluruh proses. Diakhir artikel ini, kita akan planted the seed of an Internet populated by machines Internet populated by machines, untuk mesin lain — memungkinkan kita manusia to go outside and touch grass..

Strategi SEO yang Diusulkan

Saya sudah melihat cukup banyak beberapa perusahaan melakukan SEO untuk mengetahui bahwa sebagian besar, Anda umumnya mempunyai beberapa content writers outsourcing yang mengumpulkan artikel dari sumber lain secara online. Gagasannya untuk mengotomatiskan proses ini. Alih-alih bekerja dengan penulis content, kami akan menggunakan ChatGPT untuk menulis content untuk kami.

Ini cara semuanya bekerja:

Kami mulai dengan mengorek website pilihan dan menyimpan semua kontennya.
Kami meneruskan setiap artikel ke obrolan GPT dan memintanya untuk menulis artikel baru di belakang artikel yang telah ada, dan menambahkan semakin banyak content jika relevan. Kami bahkan juga dapat mengatakannya untuk fokus ke tertentu atau pada keyword tertentu untuk membantu strategi SEO kami.

Scraping website menggunakan Python

Mari buat kelas yang menggunakan permintaan dan beautiful soup to scrape a website. Kami akan membutuhkan beberapa metode. Buat file baru bernama scraper_service.py di folder service baru, sehingga struktur directory Anda saat ini:

root/services/scraper_service.py

Optional — run:

# create a local python environment
python -m venv env
env/scripts/activate

Langkah pertama ialah membuat kelas bernama ContentScraper dan dalam kelas ini kita membuat simple function bernama generate_list_of_pages(). Ini hanya akan mengambil blog_url dan mengembalikan daftar berapa banyak halaman artikel yang dimiliki website tersebut.

import re
import requests, json
from bs4 import BeautifulSoup
from typing import *
import numpy as np

class ContentScraper:
    def __init__(self) -> None:
        pass

    def generate_list_of_pages(
        self, base_url: str, number_of_pages: int, page_param: str = "?page="
    ):
        return [f"{base_url}{page_param}{i}" for i in range(1, number_of_pages + 1)]

# output example: ["https://website.com/blog?page=1", "https://website.com/blog?page=2" ]

Ini bagus ketika kita tahu berapa banyak halaman website yang ingin kita kikis. Sebagian besar website melakukan paginasi sebagai 1,2,3,4….30 hingga Anda tidak dapat menghapus semua URL dari halaman 1. Melakukan dengan manual cukup mudah.

Langkah selanjutnya adalah menambahkan metode ke kelas ContentScraper kami yang hendak mengembalikan daftar url dengan menghapus setiap halaman yang akan dibuat oleh generate_list_of_pages.

def search_for_pages_in_parent_page(
        self,
        base_url: str,
        path_to_search_for: str,
        root_url: str,
        paths_to_exclude: List[str],
    ) -> List[str]:
        """
        base_url is the url to start scraping from
        path_to_search_for is the URL path that the nested pages must contain
        root_url is the root where the scraped URLs will be appended to
        """
        response = requests.get(base_url)
        soup = BeautifulSoup(response.content, "html.parser")
        links = []

        for link in soup.find_all("a"):
            href = link.get("href")
            if href.startswith(path_to_search_for) and not any(
                item in href for item in paths_to_exclude
            ):
                links.append(root_url + href)
        return links

Yang ingin kami lakukan di sini yaitu menentukan jalur mana yang biasanya di ikuti oleh artikel di website tersebut. Misalkan Anda mungkin memperhatikan bahwa artikel di blog yang Anda pilih untuk dikikis memiliki format URL https://website.com/blog/en/article-title-is-here dalam hal ini kami akan menyematkan path_to_search_for to be “/blog/en/”

paths_to_exlcude ialah argumen yang mengambil daftar string yang digunakan untuk mengecualikan URL dari hasil. Anda mungkin memiliki URL yang berisi "/blog/en/guidelines" yang bukan merupakan blog sebenarnya. Metode ini akan mengembalikan URL daftar artikel.

Ke kelas yang sama, kami sekarang menambahkan metode lain:

def scrape_all_content_under_tag(self, url: str, article_tag: str, title_tag: str):
        response = requests.get(url)
        soup = BeautifulSoup(response.content, "html.parser")
        body = soup.find_all(article_tag)[0].text
        title = re.sub(r"[^a-zA-Z0-9\s]", "", soup.find_all(title_tag)[0].text)

        return {"body": body, "title": title}

Ini benar-benar melakukan semua scraping yang sebenarnya untuk kita dan itu akan mengembalikan kamus yang berisi single article dengan property body and title. Ini ditujukan untuk digunakan dalam satu loop. article_tag and title_tag digunakan untuk memberitahu beautiful soup tag HTML mana yang berisi artikel di halaman. Dalam kasus saya artikel ada di bawah tag < article > dan judul berada di bawah tag < h1 > jadi hanya itu yang saya butuhkan. Anda mungkin perlu memodifikasi ini jika artikel Anda menggunakan tag < div > umum.

Ini semua yang kita butuhkan dalam hal scraping. Kami bisa membuat daftar semua halaman website, daftar setiap URL website untuk setiap halaman, dan kami bisa scraping content dari URL apa pun itu sesuai tag dan pilihan yang sudah kami tentukan. Tidak boleh khawatir bila banyak dari ini tidak masuk akal, kami akan menggabungkan semuanya diakhir artikel, dan hasil akhirnya semakin lebih jelas.

Menghubungkan ke ChatGPT menggunakan Python

Mulai dengan membuat file lain bernama chat_gpt_service.py di folder service yang sama dan buat kelas baru dengan satu sistem.

Directory Anda akan terlihat seperti ini:

root/
   services/
      scraper_service.py
      chat_gpt_service.py

import openai
import os


class ChatGpt:
    def __init__(self) -> None:
        openai.api_key = os.environ["OPENAI_API_KEY"]

    def generate_single_input_text(self, input: str):
        return openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {
                    "role": "user",
                    "content": input,
                }
            ],
            temperature=0.7,
            # max_tokens=4097,
            n=1,
            stop=None,
        )

Anda akan melihat bahwa kami menggunakan gpt-3.5-turbo sebagai model kami. Tetapi Anda dapat memilih model lain untuk ini termasuk gpt-4. Di atas ialah semua code yang diperlukan untuk terhubung secara terprogram ke ChatGPT.

Sekarang buat file.env di directory root Anda dan letakkan Kunci OpenAi Api Anda di sana:

OPENAI_API_KEY = "YOUR_API_KEY_GOES_HERE"

Membuat Beberapa Helper Functions

Kami perlu memiliki langkah untuk menyimpan scraped content, sehingga kami dapat memuatnya kapan saja ke ChatGPT, bersama dengan beberapa helper functions.

Dari directory root Anda, buat folder utils, dan dalam folder utils, buat file util.py dan logger.py sehingga kami dapat mencatat pesan debug atau kesalahan apa pun ke file.

root/
   services/
      scraper_service.py
      chat_gpt_service.py
   utils/
      util.py
      logger.py

Di util.py kita akan menangani file loads and saves dan memiliki metode lain untuk mengembalikan semua nama file di direktori tertentu:

import os, yaml


class Utils:
    def __init__(self) -> None:
        pass

    def save_file(self, filename: str, data, path="output/scraped_articles"):
        with open(f"{path}/{filename}", "w", encoding="utf-8") as file:
            file.write(str(data))

    def load_file(self, filename: str, path="output/scraped_articles"):
        with open(f"{path}/{filename}", "r", encoding="utf-8") as file:
            data = file.read()
        return data

    def get_filenames_in_folder(self, path="output/scraped_articles"):
        filenames = os.listdir(path)
        return filenames

    def load_env(self):
        return os.getenv("OPENAI_API_KEY")

Sekarang mari kita juga membuat basic logger di direktori utils yang sama:

import logging
from datetime import datetime

logging.basicConfig(
    filename=f"logs/{datetime.today().strftime('%Y-%m-%d')}_log.log",
    filemode="a",
    format="%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s",
    datefmt="%H:%M:%S",
    level=logging.DEBUG,
)

Ini akan menyimpan log kami dalam file dengan tanggal hari ini dan setiap log akan memiliki struktur berikut ini:

15:24:28,666 urllib3.connectionpool DEBUG https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None

Kembali ke direktori root, buat direktori kosong berikut hingga struktur file Anda terlihat seperti ini, dan buat file main.py yang berada di root direktori Anda:

root/
  services/
    scraper_service.py
    chat_gpt_service.py
  utils/
    util.py
    logger.py
  logs/
  output/
    scraped_articles/
    gpt_articles/
  .env
  main.py

Menyatukan semuanya (Putting it all together)

Kami sekarang memiliki semua bagian yang kami butuhkan untuk menyatukan semuanya dan melihatnya menghasilkan konten yang dioptimalkan untuk SEO dalam jumlah yang belum pernah terjadi sebelumnya.

Buka file main.py Anda di direktori root Anda:

import numpy as np

from services.chat_gpt_service import ChatGpt
from services.scraper_service import ContentScraper
from utils.util import Utils
from utils.logger import *


def main():
    scraper = ContentScraper()
    chatgpt = ChatGpt()
    util = Utils()

    saved_articles = util.get_filenames_in_folder()

    if len(saved_articles) == 0:
        # Generates a list of all the pages that contain articles
        logging.info(f"Scraping {blog_url} ")
        pages = scraper.generate_list_of_pages(
            "https://academy.binance.com/en/article", 5, page_param="?page="
        )

        # Generates a list of article URLS and flattens the array
        article_urls = np.hstack(
            [
                scraper.search_for_pages_in_parent_page(
                    page,
                    path_to_search_for="/en/articles/",
                    root_url="https://academy.binance.com",
                    paths_to_exclude= ["?page=", "/disclaimer", "guidelines"]
                )
                for page in pages
            ]
        )

        # Scrapes and saves each article as an HTML file.

        articles = [
            util.save_file(
                f"{content['title']}.txt",
                content["body"],
            )
            for content in [
                scraper.scrape_all_content_under_tag(
                    url, "article", "h1"
                )
                for url in article_urls
            ]
        ]
    else:
        logging.info(
            f"Skipping scraping as the output folder contains {len(saved_articles)} articles. If you want to re-scrape. delete everything from the output/scraped_articles folder."
        )

    logging.info("Starting ChatGPT service")
    saved_articles = util.get_filenames_in_folder()
    for article in saved_articles:
        try:
            article_body = util.load_file(article)
            response = chatgpt.generate_single_input_text(
                f"I want you to re-write the following article from a web3 perspectice and focus on keywords and search terms such as cryptocurrency: {article_body}"
            )
            print(response["choices"][0]["message"]["content"])
            util.save_file(
                article.replace(".txt", ".md"),
                response["choices"][0]["message"]["content"],
                path="output/gpt_articles",
            )
            logging.info(f"Successfully generated Article for {article}")

        except Exception as e:
            logging.error(f"ERROR encountered at {article}: {e}")
            continue


if __name__ == "__main__":
    main()

Ada beberapa hal yang terjadi di sini tapi yang kami kerjakan ialah mengulangi berbagai sistem yang sudah kami bikin di file dan langkah-langkah di atas, dan menggunakannya untuk scrape setiap URL yang berisi artikel, dan menyimpannya dengan lokal sebagai.txt file. Kami selanjutnya menggunakan service Chat GPT dan memberinya feed it each artikel yang kami hasilkan dengan mendapatkan semua nama file di folder output/scraped_articles kami. Kami menambahkan beberapa logging hingga kami tahu apa yang terjadi.

Jika semua sudah diatur benar, Anda semestinya bisa run this and watch chatGPT go , memungkinkan Anda membuat beberapa ratus artikel setiap hari, dan touch grass pada saat yang bersamaan.