Automatic Related Articles Generation for Your Blog
Why Automatic Generation of Related Articles is Needed?
Imagine: you have 500 blog posts, but a reader opens one and sees no suggestions to go to a similar article. The bounce rate reaches 70%. Manual selection doesn't scale—with hundreds of publications, you need an automated system based on tags, categories, or semantic closeness. We frequently receive such requests and implement a turnkey solution, relying on years of integration experience for large blogs. The «Similar articles» block keeps users on the site and reduces bounce rate.
How Automatic Generation of Related Articles Improves SEO?
The system automatically suggests similar content based on tags, semantics, and user behavior. By tags and categories—fast, no ML needed, but shallow. By TF-IDF—statistical closeness based on term frequency. By vector embeddings—semantic closeness, best quality, requires pgvector. In our projects, embedding-based yields 1.4x more clicks than simple tag-based and is 2x more accurate than TF-IDF for semantic similarity. The key phrase "automatic generation of related articles" is implemented through these approaches.
What algorithms for selecting similar articles exist?
| Strategy | Speed | Accuracy | Complexity |
|---|---|---|---|
| Tag-based | high | low | low |
| TF-IDF | medium | medium | medium |
| Embedding-based | low | high | high |
| Metric | Before implementation | After implementation |
|---|---|---|
| Avg time on site | 1:20 | 1:40 |
| Bounce rate | 65% | 55% |
| Clicks on related | 0% | 12% |
Source: Internal A/B tests
A common problem is tag duplication: articles with the same tags are not necessarily semantically similar. For example, an article about React hooks and an article about React routing share the tag React but differ in topic. A tag-based approach will recommend them to each other, which is ineffective. An embedding-based approach solves this problem. The choice of strategy depends on blog size: for small blogs (up to 200 articles), tag-based suffices; for large ones (over 1000), embedding-based provides a significant engagement boost.
Cost savings example: Manual selection for 1000 articles requires about 50 hours of editor time (at $50/hr, that's $2,500). With automatic generation, time reduces to 2 hours ($100). The automated solution costs around $2,000 to $5,000 depending on complexity, saving editors up to 50 hours per year.
What does the embedding-based approach provide?
The embedding-based approach with pgvector considers the semantic meaning of the article, not just common tags. In one case with 1000+ articles, implementation increased average time on site by 25% and reduced bounce rate by 15%. Articles that previously didn't overlap by tags started being recommended correctly. TF-IDF, in contrast, is 0.7x as accurate but 2x as fast. For blogs where speed matters, you can combine: first filter by tags, then rank by embeddings.
We use the OpenAI text-embedding-3-small model. For each article, we form a string from the title, excerpt, and first 2000 characters of content. The API request is made in the background via a queue. The resulting embedding is stored in a column of type vector(1536). Nearest neighbor search is performed using the <=> operator (cosine distance) with an IVFFlat index.
Tag-based approach
// SimilarArticleService
class SimilarArticleService
{
public function getSimilar(Article $article, int $limit = 4): Collection
{
if ($article->tags->isEmpty()) {
// Fallback: articles from same category
return Article::published()
->where('category_id', $article->category_id)
->where('id', '!=', $article->id)
->latest()
->limit($limit)
->get();
}
$tagIds = $article->tags->pluck('id');
// Count common tags
return Article::published()
->where('id', '!=', $article->id)
->withCount(['tags as common_tags_count' => function ($q) use ($tagIds) {
$q->whereIn('tags.id', $tagIds);
}])
->having('common_tags_count', '>', 0)
->orderByDesc('common_tags_count')
->orderByDesc('published_at')
->limit($limit)
->get();
}
}
Embedding-based approach with pgvector
// On article creation/update
class ArticleObserver
{
public function saved(Article $article): void
{
GenerateArticleEmbedding::dispatch($article)->onQueue('low');
}
}
class GenerateArticleEmbedding implements ShouldQueue
{
public function handle(): void
{
$text = implode("\n", [
$this->article->title,
$this->article->excerpt,
strip_tags(substr($this->article->content, 0, 2000)),
]);
$embedding = OpenAI::embeddings()->create([
'model' => 'text-embedding-3-small',
'input' => $text,
])->embeddings[0]->embedding;
$this->article->update(['embedding' => '[' . implode(',', $embedding) . ']']);
// Recalculate cache for this article
Cache::forget("similar_articles_{$this->article->id}");
}
}
// Query similar via pgvector
public function getSemanticallySimilar(Article $article, int $limit = 4): Collection
{
$embedding = $article->embedding;
if (!$embedding) return collect();
return Cache::remember("similar_articles_{$article->id}", 86400, function () use ($article, $embedding, $limit) {
return Article::published()
->where('id', '!=', $article->id)
->selectRaw('*, (embedding <=> ?) AS distance', [$embedding])
->whereNotNull('embedding')
->orderBy('distance')
->limit($limit)
->get();
});
}
React component with lazy loading
// SimilarArticles.tsx
export function SimilarArticles({ articleId }: { articleId: number }) {
const ref = useRef<HTMLDivElement>(null);
const [inView, setInView] = useState(false);
// Load only when block enters viewport
useEffect(() => {
const observer = new IntersectionObserver(
([entry]) => { if (entry.isIntersecting) setInView(true); },
{ rootMargin: '200px' }
);
if (ref.current) observer.observe(ref.current);
return () => observer.disconnect();
}, []);
const { data, isLoading } = useQuery({
queryKey: ['similar', articleId],
queryFn: () => fetch(`/api/articles/${articleId}/similar`).then(r => r.json()),
enabled: inView,
staleTime: 10 * 60 * 1000,
});
return (
<div ref={ref} className="mt-10">
<h3 className="text-xl font-bold mb-5">Read also</h3>
{isLoading ? (
<div className="grid grid-cols-2 gap-4">
{[...Array(4)].map((_, i) => (
<div key={i} className="h-32 bg-gray-100 rounded-lg animate-pulse" />
))}
</div>
) : (
<div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
{data?.map((article: any) => (
<a key={article.id} href={article.url}
className="group flex gap-4 p-4 border rounded-xl hover:shadow-md transition-shadow">
{article.image && (
<img src={article.image} alt="" className="w-20 h-16 object-cover rounded-lg flex-shrink-0" />
)}
<div>
<p className="text-xs text-blue-600 mb-1">{article.category}</p>
<h4 className="text-sm font-medium group-hover:text-blue-600 transition-colors line-clamp-2">
{article.title}
</h4>
<p className="text-xs text-gray-400 mt-1">{article.reading_time} min read</p>
</div>
</a>
))}
</div>
)}
</div>
);
}
Process of work
- Analytics — we evaluate the blog size, current structure, and traffic.
- Design — we choose a strategy (tag-based / TF-IDF / embedding-based) considering budget and goals.
- Implementation — we write the service, integrate with the database, and create the frontend component.
- Testing — A/B test on 20% of traffic: measure clicks on similar articles, time on site, bounce rate.
- Deployment — we go live and monitor metrics.
Timeline
Basic version on tags: 1-2 days. With embeddings and lazy loading: 3-4 working days. Timeline may vary depending on blog size and infrastructure.
Commercial Deliverables
- Full code repository access.
- PHP service (Laravel) with tag-based and/or embedding-based selection.
- Migration for pgvector.
- React component with lazy loading.
- Deployment scripts.
- Customization documentation (API docs, configuration guide).
- Developer training session (1 hour).
- 1 month of post-launch support (bug fixes, monitoring).
Metrics and guarantees
Our team has 5+ years of experience in similar projects, having completed 50+ integrations for blogs of various sizes. We guarantee the system will not affect Core Web Vitals and works correctly under 500+ concurrent requests.
If you want to implement automatic generation of related articles, contact us—we will find the optimal solution. Get a consultation on related article implementation for your blog. Order the service—we will assess the project for free.