Nicola Rizzo

Automating Anki Deck Creation with LLMs

Wed, 30 Jul 2025 00:00:00 +0000

Creating high-quality Anki flashcards manually can be time-consuming, especially when dealing with large amounts of content. I’ve developed a workflow that leverages Large Language Models (LLMs) to automate much of this process, making it significantly more efficient while maintaining quality control. The key to this approach is providing clear, detailed prompts that guide the LLM’s output. An example of a part of the prompt I use to define the rules that LLMs should follow to create, complete or fix my cards:

French-Italian Idioms CSV File Rules

This document outlines the structure and formatting rules for the french_idioms_italian.csv file.

File Format

Fields are separated by semicolons (;)

String values containing semicolons, spaces, or special characters are enclosed in double quotes (")

File uses UTF-8 encoding to support special characters

Columns The CSV contains the following columns in order:

French Expression - The complete French idiom

French Definition - The meaning of the idiom in French

Italian Translation - The equivalent idiom in Italian

Example1 - A complete sentence using the idiom with the full expression visible (not masked)

PartialCloze1 - A sentence where only the beginning of the idiom is masked with [...]

Example2 - A second complete sentence using the idiom with the full expression visible (not masked)

PartialCloze2 - A sentence where only the ending of the idiom is masked with [...]

FullCloze - A sentence where the entire idiom is masked with [...]

Register - The formality level of the idiom (Neutre, Informel, Familier)

Cloze Test Rules

[...] is used as the placeholder for masked portions of text

PartialCloze1: Masks the beginning of the expression, keeping the ending visible

PartialCloze2: Masks the ending of the expression, keeping the beginning visible

FullCloze: Masks the entire expression

All cloze examples must maintain grammatical correctness and natural flow

Example sentences should provide sufficient context to infer the missing expression

Use completely different sentences for different fields (Example1, Example2, PartialCloze1, PartialCloze2, > FullCloze) to provide varied contexts

I use placeholders ("[…]") and not cloze card types because I think it’s not possible to create cloze cards AND front/back cards in the same note.

I use CSV files as intermediate files to interact with the content of the decks. I’ve tried to use an MCP server (that I wrote using Claude Code, the MCP TypeScript SDK and the Anki Connect API specification) to connect LLMs to Anki Connect API and it works well, but it’s slow if you interact with thousands of notes. I prefer using LLM to create a Python script that loads the complete CSV file into the deck using the Anki Connect API.

I use LLMs also to reflect on card types: how to structure them? Which fields should be shown in front? Which ones in back? How to style them? Unfortunately, at the moment, Anki Connect does not allow creating or editing card types, so I had to create/edit the card types by hand.

It’s obviously an iterative process, but using LLM to create Anki decks is, by far, more productive than doing it by hand. I start, for example, by listing French expressions in a new CSV file:

1
2
3


French Expression
prendre le taureau par les cornes
chercher une aiguille dans une botte de foin

and then I ask an LLM to add a new column, French Definition for example, following the rules I listed above. When I’ve verified a sample of the results, I add the other columns, one by one. And at the end I use the Python script written by the LLM to create a new deck.

About me

Wed, 09 Aug 2023 00:00:00 +0000

Hi! I’m a software developer. I live in Italy. I’m currently working as a remote co-lead dev contractor for a French company, Helfrich (advanGO project).

LinkedIn: https://www.linkedin.com/in/rizzonicola/
Send me an email: heavy.plan1680 at fastmail dot com

WIP - Work In Progress in my blog

Tue, 08 Aug 2023 00:00:00 +0000

In my blog I prefer to share as soon as possible what I’m working on and what I’m writing about. When there is a small amount of value in what I’m writing, I don’t wait to end it to publish it. Obviously these WIP (Work In Progress) pieces could be incomplete (duh!), not entirely correct (waiting factchecking), and/or readable (waiting editing).

I use this Hugo shortcode

1

{{% wip %}}

to include WIP sections in my posts. This shortcode corresponds to this rendered section:

This is a Work In Progress (WIP).

I’ve also found a simple solution for a problem in the RSS feed: when I’m working on a WIP piece I dont’t want to send an RSS item for every single editing, but I would like to create a new RSS item after an important update. To do that, I use the guid tag (https://www.rssboard.org/rss-specification#ltguidgtSubelementOfLtitemgt) in the RSS Hugo template:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
 <channel>
 <item>
 <!-- ... -->
 {{ if (not (.Params.rssGuid)) }}
 <guid>{{ .Permalink }}</guid>
 {{ else }}
 <guid>{{ .Params.rssGuid }}</guid>
 {{ end }}
 <description>{{ .Content | html }}</description>
 </item>
 <!-- ... -->
 </channel>
</rss>

and in the frontmatter of the WIP post I write:

1
2
3
4


---
# ...
rssGuid: f0632b25-fb5c-404c-977c-c0e7f17f1afb
---

I use UUIDv4 for the rssGuid. When I want to send an update to my RSS feed followers, I generate a new UUID and remplace the value in the rssGuid parameter.

A double RSS item (Published writers' notebooks) in my feed after changing the guid value

Compile and load SQLite extensions

Sat, 05 Aug 2023 00:00:00 +0000

How to compile the UUID extension:

1
2
3
4
5
6
7


wget https://www.sqlite.org/src/tarball/sqlite.tar.gz
tar xzf sqlite.tar.gz
mkdir bld
cd bld
../sqlite/configure
make
gcc -g -I. -fPIC -dynamiclib ../sqlite/ext/misc/uuid.c -o uuid.dylib

Run the sqlite3 command-line program:

1

./sqlite3

Try to use the UUID extension without loading it:

1
2
3
4


sqlite> select uuid();
Parse error: no such function: uuid
 select uuid();
 ^--- error here

Load the UUID extension and use it:

1
2
3


sqlite> .load ./uuid
sqlite> select uuid();
945ef12d-f428-4b8a-831c-3a2fbe7c60b4

Tested on an Intel Macbook Pro.

Source: https://stackoverflow.com/a/61850934

How to create tables with primary key UUID columns in SQLite

Sat, 05 Aug 2023 00:00:00 +0000

After loading the UUID extension, in SQLite you can create tables with a UUID primary key with an automatic value defined by its default value:

1
2
3


create table my_table (
 uuid blob primary key default(uuid_blob(uuid())),
);

Something like autoincrementing for UUID columns.

Automating PDF Table of Contents Creation Using AI and PDFtk

Sat, 25 Feb 2023 00:00:00 +0000

Adding a Table of Contents (ToC) to a PDF file can be a tedious process, but with the right tools, it can be almost automated. In this guide, we’ll use AI to generate the ToC entries from images and PDFtk to integrate them into the PDF.

Step 1: Create a CSV File Containing the Table of Contents Entries

To generate the ToC entries, we can use AI to extract them from images of the book’s table of contents. Use a prompt like the one below:

You are a system that, given an image of part of a book’s table of contents, extracts the data and tabulates it. The columns are:

level (1 for chapters, 2 for sections)
page (for chapters, use the page of the first section)
title

The output must be the contents of a CSV file.

Do not respond with anything other than the contents of the CSV file. All provided images must be tabulated without asking for confirmation.

Customize the prompt as needed and send it to an AI model along with images of the book’s table of contents. The AI will return structured text, which you can save as a CSV file.

Step 2: Check and Clean the CSV File

Before converting the CSV file to a format suitable for PDFtk, review the extracted data. Ensure that:

The page numbers are correct.
The section titles are properly formatted.
There are no missing or extra entries.

Step 3: Convert CSV to PDFtk Table of Contents Format

Once the CSV file is cleaned, convert it into the format required by PDFtk using the following Python script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import csv

# Define the path to your CSV file and the output text file
csv_file = 'bookmarks.csv'
output_file = 'bookmarks.txt'

# Open the CSV file and read the content
with open(csv_file, newline='', encoding='utf-8') as file:
 reader = csv.reader(file)

 # Open the output text file in write mode
 with open(output_file, 'w', encoding='utf-8') as output:
 # Loop through each row in the CSV file
 for row in reader:
 # Extract title, page number, and bookmark level
 title = row[0]
 page_number = row[1]
 bookmark_level = row[2]

 # Write the formatted bookmark information to the text file
 output.write(f"BookmarkBegin\n")
 output.write(f"BookmarkTitle: {title}\n")
 output.write(f"BookmarkLevel: {bookmark_level}\n")
 output.write(f"BookmarkPageNumber: {page_number}\n")

print(f"Bookmarks have been written to {output_file}")

This script transforms the structured CSV data into a format that PDFtk can interpret for adding bookmarks to the PDF.

Step 4: Extract Data from the PDF File Using PDFtk

To integrate the Table of Contents, first extract the existing PDF metadata with the following command:

1

pdftk input.pdf dump_data_utf8 > in-utf8.info

This will produce a file containing the metadata of the PDF, which we will modify in the next step.

Step 5: Edit the PDFtk Data File

Open the extracted data file and insert the Table of Contents entries obtained in Step 3. Ensure that:

The entries are properly structured.
They align with the correct page numbers.
The hierarchy is maintained (if applicable).

Step 6: Generate the Final PDF with the Table of Contents

Finally, apply the modified data file to the original PDF using the following command:

1

pdftk input.pdf update_info_utf8 in-utf8.info output out.pdf

This will create a new version of the PDF with the Table of Contents integrated.

How to improve performances for SQL queries with IN and thousands of values

Wed, 09 Nov 2022 00:00:00 +0000

Today I’ve had to optimize an SQL query with this structure:

1
2
3


SELECT ...
FROM ... tbl
WHERE tbl.id IN (435, 3456, 77432, ...) -- thousands of values here

A very simple query, but having thousands of values after IN causes very bad performances.

Some Internet searches have allowed me to find an equivalent query to do that, but faster:

1
2
3
4
5
6


CREATE TEMPORARY TABLE tmp (id INT NOT NULL, PRIMARY KEY (id));
INSERT INTO tmp (id) VALUES (435), (3456), (77432), ..... -- thousands of values here
SELECT ...
FROM ... tbl
INNER JOIN tmp ON tmp.id = tbl.id;
DROP TABLE tmp; -- optional, it depends on following requests

I’ve had to create a temporary table and insert into it all IDs and INNER JOIN it. Optionally, you can drop the table after the request, but the table lives only during the session anyway.

About SVGs flexibility: dark mode

Mon, 07 Nov 2022 00:00:00 +0000

As an owner of a cheap Wacom tablet, it’s quite simple for me to create “handmade” SVG files using, for example, a vector graphics editor, like Inkscape, Adobe Illustrator or Affinity Designer. After creating the file, with a text editor or IDE you can open it and read its code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg
 width="100%"
 height="100%"
 viewBox="0 0 516 517"
 version="1.1"
 xmlns="http://www.w3.org/2000/svg"
 xmlns:xlink="http://www.w3.org/1999/xlink"
 xml:space="preserve"
 xmlns:serif="http://www.serif.com/"
 style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">

 <path d="M176.207,107.015c2.995,..."/>

 <path d="M180.577,208.347c6.706,-20.119 13.374,..."/>

 ...
</svg>

It turns out that you could change this code and adapt to your needs. For example, you can style it to adapt its color according to the dark mode option:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<svg>
 <style>
 path {
 fill: black;
 }
 body.dark path {
 fill: white;
 }
 </style>

 <path
 d="..."
 fill="currentcolor"
 />
<!-- ... -->
</svg>

In this code snippet, the CSS class dark is the class I use to activate the dark mode in the body.

The same SVG file with the dark mode option enabled and disabled

Document your project adding Sphinx to docker-compose.yml

Mon, 02 Sep 2019 12:00:00 +0000

I strongly believe that a web application project has to be thoroughly documented. And that’s more important for larger and longer project, where developers come and go in an unstoppable turnover that risks to slow down the project. A documentation is the only chance for new developers to become rapidly productive.

But how we, as developers, can document a project? What tools exist out there that can facilitate this task? Well, there are dozens of tools. One of them is Sphinx, the Python Documentation Generator. This library can be used to document everything you want. You can think it as a static site generator, like Jekyll, Hugo or Gatsby, but more oriented to technical documentation. You can host it somewhere, like on the Read The Docs, or keep it locally. In this article I will explain how to use it locally with a project already using Docker Compose.

The Dockerfile

Let’s begin writing a simple Dockerfile for Sphinx:

1
2
3
4
5
6
7
8
9


FROM alpine:latest
WORKDIR /etc/
RUN mkdir -p /etc/Sphinx/build

RUN apk add --no-cache python3 make git
RUN pip3 install git+https://github.com/sphinx-doc/sphinx && \
 pip3 install sphinx-autobuild

CMD sphinx-autobuild -b html --host 0.0.0.0 --port 80 /etc/Sphinx/source /etc/Sphinx/build

Here, after using the latest Alpine image and creating some folders, I install some dependencies (python3, make, git); after that, I install sphinx and its autobuild. The Sphinx-autobuild project automatically rebuild the documentation after a change in the documentation folder is detected, and it works like a charm also with Docker. With its livereload web server, this library serves also the documentation web page, allowing you to access to the documentation with a browser visiting a URL like http://localhost:8100.

The docker-compose.yml file

Let’s add now a service to the docker-compose.yml already used in the application project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


version: "3"

# ...
services:
 # ...
 service_doc:
 container_name: service_doc
 build: docker/doc
 volumes:
 - ./doc:/etc/Sphinx/source
 ports:
 - 8100:80
# ...

The folder structure of the project is something like:

.
├── doc
├── docker
│ └── doc
│ └── Dockerfile
└── docker-compose.yml

I’ve defined a volume in the folder ./doc, where there will be the documentation folders and files. The Sphinx Dockerfile presented above is in the folder ./docker/doc and the docker-compose.yml is in the root folder. The URL to use to visit the documentation is http://localhost:8100.

The Sphinx quickstart

I can now run the command:

1

docker-compose up -d

With this command, I’ve created a container with Sphinx. To continue, I have to create a configuration file, conf.py, in the folder ./doc. To do that, I’ve run the following command in the container (after running docker-compose exec service_doc /bin/sh):

1

sphinx-quickstart

After answering some questions about my project, the command generates some files. I’ve moved the autogenerated conf.py and index.rst in the /etc/Sphinx/source folder in the container:

1
2


mv conf.py /etc/Sphinx/source
mv index.rst /etc/Sphinx/source

Writing the documentation using Sphinx

We can now access the (empty) documentation at http://localhost:8100. If we try changing the index.rst file, after some seconds the browser auto refresh to show the updated documentation. Following the Sphinx documentation site you can now document your project using Sphinx.