DEV Community: Shamsuddin Ahmed

Green Padlock, Zero Headache: Let’s Encrypt SSL for Self-Hosted Dify

Shamsuddin Ahmed — Thu, 08 May 2025 18:06:34 +0000

“Your app isn’t production until the padlock turns green.”
This guide merges the one-liner speed of the quick-start and the step-by-step clarity of the original long-form post.

Follow along and you’ll mint fresh Let’s Encrypt certificates, wire them into Dify’s Nginx, and set-and-forget auto-renewal—all in ~15 minutes.

0 Why bother?

✅ Win	🚀 Why it matters
End-to-end encryption	Keep chat sessions & API calls private.
Browser trust	No more red “Not secure” labels.
Free & automated	Let’s Encrypt renews every 60–90 days without a credit-card or cron anxiety.

1 Prerequisites

Domain – A/AAAA record → your server
Ports – 80 & 443 open on firewall/cloud SG
Docker – v24 + Compose v2 (docker compose version)
Dify repo – git clone https://github.com/langgenius/dify.git && cd dify/docker

2 Patch `.env` (tell Dify who it is)

# --- SSL filenames Nginx expects
NGINX_SSL_CERT_FILENAME=fullchain.pem
NGINX_SSL_CERT_KEY_FILENAME=privkey.pem

# --- Let Certbot answer ACME challenges
NGINX_ENABLE_CERTBOT_CHALLENGE=true

# --- Your domain + a real e-mail
CERTBOT_DOMAIN=dify.example.com
CERTBOT_EMAIL=ops@example.com

# --- Leave this OFF until the cert exists
NGINX_HTTPS_ENABLED=false

Got multiple sub-domains?
Add APP_WEB_URL, APP_API_URL, CONSOLE_WEB_URL, and CONSOLE_API_URL, each with https://… so Dify’s front-end matches its back-end once HTTPS is live.

3 (Tidy-up) Prune stray Docker networks

Old bridges sometimes clash with the Certbot profile.

docker network prune        # hit y when asked

4 Launch the stack with the Certbot profile

docker compose --profile certbot up --force-recreate -d

Flag	Why we need it
`--profile certbot`	Starts nginx + certbot side-cars.
`--force-recreate`	Rebuild nginx so it mounts the Let’s Encrypt volume.
`-d`	Runs in the background (detached).

5 Run Certbot inside its container

docker compose exec -it certbot /bin/sh /update-cert.sh

What just happened?

Certbot spins a micro webroot on :80.
Let’s Encrypt validates dify.example.com.
Keys drop into volumes/certbot/conf/live/dify.example.com/.

Expect the triumphant:

Congratulations! Your certificate and chain have been saved at:
  /etc/letsencrypt/live/dify.example.com/fullchain.pem

6 Flip the HTTPS switch

# in docker/.env
NGINX_HTTPS_ENABLED=true

7 Recreate only nginx (fast restart)

docker compose --profile certbot up -d --no-deps --force-recreate nginx

Nginx boots, finds fullchain.pem & privkey.pem, and starts serving 443.

8 Verify the green padlock

https://dify.example.com

You should see:

🔒 Green padlock
Auto-redirect from http:// → https://

9 Renewal in two commands (bookmark this)

Let’s Encrypt certs last 90 days. Certbot’s built-in cron renews them, but here’s the manual drill:

# 1. Force renew (safe to run anytime)
docker compose exec -it certbot /bin/sh /update-cert.sh

# 2. Hot-reload nginx to pick up the new files
docker compose exec nginx nginx -s reload

10 Troubleshooting cheat-sheet

🛠️ Symptom	💡 Fix
`timeout during connect (likely firewall)`	Port 80 closed or DNS not propagated.
`Permission denied` on `/update-cert.sh`	Script lost its +x bit—`chmod +x /update-cert.sh` inside the image or rebuild.
Infinite “Loading…” UI	All five `_WEB_URL` / `_API_URL` env vars must match the new `https://…` URL.
`bind: address already in use: 0.0.0.0:80`	Another web server running—stop Apache/old Nginx or change Compose ports.

11 Recap (copy-paste edition)

# 0  clone repo & cd dify/docker
# 1  edit .env  → domain, e-mail, filenames
# 2  docker network prune
# 3  docker compose --profile certbot up --force-recreate -d
# 4  docker compose exec -it certbot /bin/sh /update-cert.sh
# 5  set NGINX_HTTPS_ENABLED=true in .env
# 6  docker compose --profile certbot up -d --no-deps --force-recreate nginx

Fifteen minutes, one free cert, zero recurring fees—your Dify instance is officially production-grade.

Happy shipping!

Homomorphic Encryption (HE) Explained: A Beginner’s Guide to Secure AI on Encrypted Data

Shamsuddin Ahmed — Thu, 01 May 2025 22:35:44 +0000

Imagine this: You send a message to a server. That message is completely encrypted—nobody can read it. But the server still knows whether your message is harmful or not. It didn't decrypt it. It didn't peek inside. It just... ran a program on the encrypted data. Sounds like magic? That’s Homomorphic Encryption (HE).

In this post, we’ll break down what homomorphic encryption is, why it matters in today’s privacy-first digital world, and how you can start experimenting with it—even if you don’t have a background in cryptography or security.

🔐 What Is Homomorphic Encryption?

Homomorphic Encryption (HE) is a way to do calculations on data without decrypting it.

🤯 Wait, what?

Let’s say you lock a number in a box (5 → 🔒5) and send it to a server. The server doesn’t unlock the box. But somehow, it adds 3 to the locked number and sends back a locked result. You open the box later and get... 8.

That’s the power of HE: you can process encrypted data and only decrypt the result later.

💡 Why Should You Care?

In a world where privacy is everything—from end-to-end encrypted messaging to secure medical data—HE enables systems to analyze and process data without ever seeing it.

Use cases:

🔍 Detect child exploitation in encrypted messages
🏥 Analyze encrypted medical records
📊 Run secure AI models without leaking user data
💬 Filter toxic messages in encrypted chats

🧠 How Does HE Work (Simple Version)

All HE systems work with a few basic ideas:

You encrypt a number: Let’s say m = 5 becomes Enc(m) = 🔒5
You perform math on the encrypted number: For example, Enc(5) + Enc(3)
You decrypt the result: You get 5 + 3 = 8

So Decrypt(Enc(5) + Enc(3)) = 8

But here’s the twist: The server never saw the 5 or the 3. Just the encrypted stuff.

🍱 Types of Homomorphic Encryption

There are several types of HE:

Type	What It Can Do	Example
Partial HE (PHE)	Only one operation (add or multiply)	Paillier (add), RSA (multiply)
Somewhat HE (SHE)	A few operations (limited depth)	Good for simple tasks
Fully HE (FHE)	Unlimited operations	The holy grail—do anything!

The most famous FHE system was invented by Craig Gentry in 2009. Since then, it's become faster and more usable every year.

🤖 HE + Machine Learning = Privacy-Preserving AI

Let’s talk AI. You want to build a model that detects bad messages... but the messages are encrypted. Can HE help?

Yes.

Here’s how:

The user encrypts their message.
The server runs a machine learning model on the encrypted data.
The output is encrypted too.
Only the user (or a trusted party) decrypts the result.

Nobody sees the actual message. Ever. But we still get a result like:

✅ Safe

🚫 Violating

🛠️ How To Get Started with Homomorphic Encryption (In Python)

Let’s get practical. There are several Python libraries that make HE accessible—even for beginners.

🧰 Tools You Can Use

Library	Best For	Notes
TenSEAL	Easy encrypted ML in Python	Built on Microsoft SEAL
Microsoft SEAL	Hardcore HE with C++ performance	Very powerful
PySyft	Federated + encrypted ML	Works with PyTorch
Pyfhel	Lightweight Python HE	Good for learning
Concrete-ML	ML → FHE pipeline	Great for fast demos

🔢 Simple Example: Encrypted Classification in Python

Let’s say we want to classify a message as safe or not safe. We’ve got two features:

Suspicious keywords count
Message length

We encrypt these features, apply a linear model, and decrypt the result.

import tenseal as ts

# Setup encryption context
context = ts.context(
    ts.SCHEME_TYPE.CKKS,
    poly_modulus_degree=8192,
    coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40

# Share this with the user for encryption
public_context = context.copy()
public_context.make_context_public()

# User encrypts their features
features = [3.0, 50.0]  # 3 bad keywords, 50 characters
enc_features = ts.ckks_vector(public_context, features)

# Model: score = 0.5*x1 - 0.3*x2 + 0.1
weights = [0.5, -0.3]
bias = 0.1

# Server evaluates the model on encrypted data
enc_score = enc_features.dot(weights)
enc_score += bias

# Server sends result back for decryption
decrypted_score = enc_score.decrypt()[0]
print("Score:", decrypted_score)
print("Class:", "violating" if decrypted_score > 0 else "safe")

🧪 This example shows HE in action: a server can run a model on encrypted data. Only the client sees the result.

🧭 Where to Go Next?

Try TenSEAL – It's great for Python users who want encrypted ML.
Read up on CKKS – It’s the HE scheme most used in AI.
Think of a use case – How could you apply HE in healthcare, finance, or messaging?

⚠️ Real Talk: Challenges of HE

Homomorphic encryption is powerful, but it's not perfect.

Challenge	Notes
🚀 Slower than plaintext	But improving fast! Use batching and approximate math
🤹‍♂️ Only supports + and ×	Use polynomials to approximate activations
🔊 Noise grows with operations	Choose parameters carefully
📦 Data gets large	One ciphertext can be ~10KB-100KB

Still, it’s absolutely worth learning if you care about privacy-first machine learning.

✅ Final Thoughts

Homomorphic encryption lets you compute on secrets. That’s huge.

It means we can have:

AI without surveillance
Insight without exposure
Safety without spying

If you’re dreaming about building AI that respects user privacy—even on encrypted messages—this is your starting point.

Let’s build the future where privacy and AI work together, not against each other.

Retrieval Metrics Demystified: From BM25 Baselines to EM@5 & Answer F1

Shamsuddin Ahmed — Tue, 29 Apr 2025 10:38:04 +0000

“If a fact falls in a database and nobody retrieves it, does it make a sound?”

Retrieval‑Augmented Generation (RAG) lives or dies on that first hop—can the system put the right snippets in front of the language model?

In this post, we peel back the buzzwords (BM25, EM@5, F1) and show how to turn them into levers you can actually pull.

1. Why bother measuring retrieval separately?

End‑to‑end metrics (BLEU, ROUGE, human ratings) blur two questions together:

Did I pull the right passages?
Did the generator use them well?

Untangling the knot matters. If you log a 5‑point jump in answer F1, you want to know where the jump came from—better retrieval, a smarter prompt, or a lucky seed? The retrieval metrics below give you that X‑ray.

2. BM25—the keyword workhorse

Before transformers, there was the inverted index: a glorified phonebook where every word points to the documents it lives in. BM25 (“Best Match 25”) is the score those phonebooks still use today:

\operatorname{BM25}(q,d)=\sum_{t\in q} \text{IDF}(t)\;\frac{f(t,d)(k_1+1)}{f(t,d)+k_1\left(1-b+b\frac{|d|}{\overline{|d|}}\right)}

f(t,d) = term frequency of t in document d
|d| = token length of d
IDF(t) = inverse document frequency
Default hyper‑parameters: $k1≈1.2k_1 \approx 1.2$ , $\approx 0.75$

Mental model: BM25 is a tug‑of‑war between how often a query word shows up and how common that word is across the whole corpus.

Why keep it around?

Speed – microseconds per query on millions of docs.
Transparency – devs can still debug with Ctrl‑F.
Baseline gravity – if you can’t beat BM25, something’s off.

3. EM@k—Exact Match at k

Imagine playing Where’s Waldo? but you’re allowed to search the first k pages instead of the whole book. EM@k asks: “Does any of my top‑k passages contain the gold answer string **exactly?”

Algorithm for a question set of size $N$ :

Retrieve top‑k passages per question.
Mark hit = 1 if at least one passage contains the gold answer, otherwise 0.
$EM@k=∑i=1NhitiN\text{EM@k} = \frac{\sum_{i=1}^{N} \text{hit}_i}{N}$

Why the fuss over exact match?

Because partial overlaps (“2008 financial crash” vs. “the 2008 recession”) are slippery to grade at retrieval time. EM@k stays dumb on purpose—either the string shows up or it doesn’t.

Rule‑of‑thumb:

EM@5 ≥ 80% → retrieval is likely not your bottleneck.

EM@5 ≤ 60% → focus on the retriever before prompt‑tuning.

4. Answer‑level F1—did the generator actually use the context?

Once your passages hit the jackpot, the generator still has to say the answer. For extractive QA, the go‑to metric is token‑level F1:

\text{F1} = \frac{2 \times \text{precision} \times \text{recall}}{\text{precision} + \text{recall}}

Component	Definition
Precision	Tokens in the model answer ∩ tokens in the gold answer ÷ tokens in the model answer
Recall	Tokens in the model answer ∩ tokens in the gold answer ÷ tokens in the gold answer

F1 forgives small wording tweaks—“Barack Obama” vs. “Obama”—in a way EM cannot.

5. From BM25 to Dense Retrieval & Reranking

Stage	Model	What changes	Why you win
Dual‑encoder	Dense Passage Retriever	Index contains 768‑D vectors, not word positions	Captures synonyms (“terminate” ≈ “cancel”)
Cross‑encoder	MiniLM, MonoT5…	Re‑score $d[\text{CLS}] q\;[SEP]\;d$ with full token interactions	Sharp ordering; filters noise

A typical contract QA study logged:

BM25 → 61% EM@5
DPR + Cross‑encoder → 79% EM@5

Same corpus, same questions—just a richer notion of “relevance”.

6. Other retrieval diagnostics you’ll meet in the wild

Metric	What it asks	Best when…
Recall@k	Any gold passage in top‑k?	Gold labels are full passages, not spans
MRR	How early is the first correct hit?	You care about position 1 above all
MAP	How well are all relevant docs ranked?	Multiple correct passages per query
nDCG@k	Same as MAP but with graded (0–3) relevance	Web search, ad ranking

7. Hands‑on: computing EM@5 in Python

from typing import List

def em_at_k(retrieved: List[List[str]], gold: List[str], k: int = 5) -> float:
    """retrieved[i] is the ranked list for question i; gold[i] the gold answer string"""
    hits = sum(any(gold[i] in doc for doc in retrieved[i][:k]) for i in range(len(gold)))
    return hits / len(gold)

Pro tip: pre‑lowercase and strip punctuation on both sides to avoid false misses.

8. Cheat‑sheet 🧾

BM25         – bag‑of‑words baseline; fast, transparent
EM@k         – % questions whose answer text appears in top‑k passages
Answer F1    – token overlap between generated and gold answer
Dense Retr.  – dual‑encoder embeddings; higher recall than BM25
Cross‑encode – reranks with full attention; boosts top‑1 precision

9. Try it yourself 🧪

FAQ Retriever Bake‑Off Index your company FAQ with BM25 and DPR; measure EM@5 on a 50‑question test set. Which wins?
Prompt‑Effect Audit Freeze retrieval; vary only the generation prompt. How much does answer F1 move? Log your findings in a two‑column table.
Metric Mixing Board Build a dashboard that shows EM@1, EM@5, Recall@20, and answer F1 side by side for each experiment run.

10. Final words

Like good coffee, a RAG system is only as strong as its first extraction. Nail the retrieval metrics, and the language model can do what it does best—explain, summarise, and synthesise without hallucinating. Happy hunting, and may your EM curves trend ever upward!

11. Live Demo in Colab

I've packed the full retrieval-metrics pipeline—including BM25 retrieval, EM@k scoring, token-level F1, and EM-curve plotting—into a runnable Google Colab notebook. Click below to open, run, and experiment:

Open the “Retrieval Metrics Demystified” Colab notebook

Feel free to:

Fork and modify the corpus or QA set
Tune BM25 hyper-parameters (k1, b)
Swap in a dense retriever or reranker
Plot EM@k curves on your own data

Comments and pull-requests on the notebook are very welcome—let me know what you build!