Playing with Ollama - Create a blog post analyzer with a local LLM

Tagging blog posts by hand does not scale — and neither does spotting, across a few hundred posts, which ones actually belong together. I wanted to see whether a local model, given nothing but the raw Markdown, could generate reasonable tags and then use those tags to suggest interlinks on its own.

The Result​

Once both scripts have run, output/all_articles_with_tags.json holds the generated tags for every post:

The second script then compares those tags across posts. suggested_interlinks.json is the first output worth looking at:

[
  {
    "source_article": "001-intro-to-docker.md",
    "suggested_links": []?
  },
  {
    "source_article": "004-local-llms-future.md",
    "suggested_links": ["002-getting-started-with-ollama.md"]?
  },
  {
    "source_article": "003-advanced-python.md",
    "suggested_links": []
  },
  {
    "source_article": "002-getting-started-with-ollama.md",
    "suggested_links": ["004-local-llms-future.md"]?
  }
]

Articles 002 and 004 are correctly identified as related — they both talk about local LLMs. Articles 001 and 003 are left alone, since they cover unrelated topics. Sounds good!

The second output file, tag_analysis.json, shows the tags and their occurrences across the articles. In this small sample, "local LLMs" appears in two articles (002 and 004) while every other tag appears in only one:

{
  "total_unique_tags": 23,?
  "top_tags": [?
    {
      "tag": "local",
      "count": 2
    },
    {
      "tag": "LLMs",
      "count": 2
    },
    {
      "tag": "docker",
      "count": 1
    },
    {
      "tag": "containers",
      "count": 1
    },
    {
      "tag": "images",
      "count": 1
    },
    {
      "tag": "compose",
      "count": 1
    },
    {
      "tag": "future",
      "count": 1
    },
    {
      "tag": "AI",
      "count": 1
    },
    {
      "tag": "development",
      "count": 1
    },
    {
      "tag": "advanced",
      "count": 1
    },
    {
      "tag": "python",
      "count": 1
    },
    {
      "tag": "scripting",
      "count": 1
    },
    {
      "tag": "decorators",
      "count": 1
    },
    {
      "tag": "generators",
      "count": 1
    },
    {
      "tag": "context",
      "count": 1
    },
    {
      "tag": "managers",
      "count": 1
    },
    {
      "tag": "rest",
      "count": 1
    },
    {
      "tag": "api",
      "count": 1
    },
    {
      "tag": "language models",
      "count": 1
    },
    {
      "tag": "Ollama",
      "count": 1
    }
  ]
}

Why It Works​

• One script per responsibility: the first script only talks to the LLM and produces tags; the second only reads those tags and computes relationships — no single script does both.
• Tags are the only signal used for linking. Two posts sharing a tag are considered related; the more tags they share, the stronger the suggestion.
• Nothing here is Docusaurus-specific — swap data/posts for any folder of Markdown files and the same two scripts produce the same kind of analysis.

Installation​

Copy the directory structure and files​

Please run the following command in your terminal to copy the directory structure and files for this tutorial:

Once done, please run code . to open the current directory in Visual Studio Code then press Ctrl+Shift+P and select Devcontainers: Reopen in Container to open the project in a development container.

It will take a few minutes to build the container and install the dependencies. Once the devcontainer is running, you'll see in your Docker Desktop that the two containers are running:

Download the LLM model​

Then, return to your terminal (on your host) and run the following command to download the LLM model:

$ docker exec -it tags-ollama-1 ollama pull llama3:8b

Test the Ollama service​

So we've just downloaded the LLM model, now let's test that the Ollama service is working correctly. Run the following command in your terminal (on your host):

$ curl --silent http://localhost:11444/api/tags | jq

curl --silent http://localhost:11444/api/generate \
  -d '{\
    "model": "llama3:8b", \
    "prompt": "Explain in one sentence why Docker is so amazing.", \
    "stream": false \
  }' | jq .response

Ok, the service is working, and we can see that the tags endpoint is available. This endpoint will be used by our Python scripts to send the content of the blog posts and receive the generated tags.

More Demos​

Run the tag generation script​

Go back to Visual Studio Code, jump in the terminal (in VSCode) and run the scripts/01_generate_tags.py file. This script will read all the Markdown files in the data/posts directory, send their content to the LLM model running in the container, and save the generated tags in a JSON file.

And, indeed, you can see that the output/all_articles_with_tags.json file has been created — the tags shown earlier under "The Result" are exactly what this run produced.

Run the analyze and link script​

The second script, scripts/02_analyze_and_link.py, reads the generated tags from that JSON file and produces the suggested_interlinks.json and tag_analysis.json files shown above.

Under the Hood (skip this if you just want to use it)​

Choosing the Right Model​

In this article, I used llama3:8b as a starting point. However, the true beauty of Ollama lies in the flexibility to swap "brains" depending on the task at hand. The Ollama registry offers a vast library of models, but choosing the right one depends on your available hardware — specifically your RAM and GPU.

Model Comparison at a Glance​

Which one should you pick?​

• Go for llama3:8b if you are just getting started or have limited RAM. It is perfect for rapid prototyping and simple automation tasks that don't require deep logical reasoning.
• Try mistral if you find Llama 3's responses a bit too rigid. Many developers prefer Mistral for its creative flair and efficiency. It's an excellent "daily driver" for general coding support.
• Scale up to llama3:70b if you are performing tasks that demand high precision — such as refactoring complex codebases, deep logical debugging, or processing large datasets where accuracy is critical. Because this model is massive, it significantly reduces "hallucinations," making it the most reliable choice for professional work.

Downloading your models​

You can add any of these models to your local environment instantly. Simply run the following commands in your terminal:

To pull the standard Llama 3 (8B) model:

$ docker exec -it tags-ollama-1 ollama pull llama3:8b

To pull the highly capable Llama 3 (70B) model:

$ docker exec -it tags-ollama-1 ollama pull llama3:70b

To pull the Mistral model:

$ docker exec -it tags-ollama-1 ollama pull mistral

Note: The 70b model is significantly larger (~40GB). Ensure you have enough disk space and, more importantly, at least 48GB of RAM available to ensure the model runs smoothly without slowing down your system.

Conclusion​

Two small Python scripts and a local model turned a folder of Markdown posts into a tag index and a set of interlink suggestions — no cloud API, no manual tagging, and nothing about the pipeline is specific to Docusaurus. Point data/posts at any folder of Markdown files and the same two scripts do the same job.

Turning a suggestion like "articles 002 and 004 are related" into an actual <Link> in the prose is still a manual step here — the natural next iteration is having the second script propose the exact sentence and anchor text, not just the pair of files.