DEV Community: techtech

Bento.me is Gone, so I Built My Own (For Free)

techtech — Thu, 05 Mar 2026 15:26:37 +0000

If you've ever relied on Linktree, Bento.me, or any other link-in-bio platform, you probably know the frustration: limited customization on the free plan, features locked behind a paywall, and sometimes — the service just goes down.

That's exactly why I built Linkbase — a fully open-source, self-hostable link-in-bio platform. And here's the kicker: everything is free, forever.

What is Linkbase?

Linkbase is a modern link-in-bio platform that gives you:

A beautiful bento grid profile page with drag-and-drop editing
A built-in blog — write and publish articles directly on your profile
Short link creation with real-time click tracking
AI theme generator — describe a vibe, get a color scheme
Detailed analytics — see which links and pages perform best
Social embeds for YouTube, Spotify, GitHub, Instagram, and more
QR code cards, testimonial widgets, FAQ blocks
Full design control: fonts, gradients, borders, corner radii — everything

All of this, at $0. No credit card required.

Who is it for?

Anyone who wants a single link to represent everything they do online:

Developers sharing their GitHub projects and blog
Creators linking their YouTube, Spotify, and social profiles
Freelancers using it as a digital business card
Anyone who was burned by a third-party bio-link tool going down

Linkbase vs. the Competition

Here's a quick comparison of what you get for free:

Feature	Linkbase	Others (free tier)
Unlimited links & pages	✅	Paid
Built-in blog	✅	Paid
Short link tracking	✅	Paid
Social embeds	✅	Paid
AI theme generator	✅	Paid
Bento grid layout	✅	Paid
Price	Free forever	$5–24/mo

Try it Out

➡️ links.schächner.de

Sign up in seconds — just your email, no credit card. Build your page, add your links, write a blog post, and share one link everywhere.

Linkbase is still being actively developed, and early users directly shape the roadmap. If you have feature requests or feedback, drop them in the comments — I read everything.

Built with a focus on performance, privacy, and full user control. Self-hosting documentation coming soon.

Bento.me and Linktree alternative! Check it out!

techtech — Mon, 23 Feb 2026 18:16:52 +0000

techtech

Feb 23

Bento.me is down, so I built my own

#website #linktree #bio

Comments 4

2 min read

Bento.me is down, so I built my own

techtech — Mon, 23 Feb 2026 18:14:03 +0000

Bento.me, a really nice link-in-bio tool, has been gone for a while now. So I created one myself using AI!

I wanted something that:

I fully control
Looks actually good
has many personalization options
Is fast and lightweight
Has room to grow (blog, analytics, embeds...)
Not just optimized for mobile devices

Introducing Linkbase

So I built Linkbase — a vibrant, customizable link-in-bio platform that lives at our own domain.

Here's what it offers right now:

Full Design Control

Forget boring templates. With Linkbase you can fine-tune colors, backgrounds, borders, corner radiuses — basically every visual aspect of your profile page. It's your page, it should look like you.

Integrated Blog

This was a big one for me. Instead of linking out to a separate blog platform, Linkbase comes with a built-in blog. Write articles, share updates, connect with your audience — all from one place, under your own brand.

All Your Content in One Place

Link to your socials, embed a Spotify track, feature another creator's profile. Linkbase is meant to be your central hub for everything you do online.

Analytics (Coming Soon)

Deep insights into your audience are on the roadmap — which links get the most clicks, what content resonates, and more.

The Stack

It's a modern web app with a focus on performance and a clean developer experience. Everything is hosted under my own domain (links.schächner.de), which means I'm in full control of availability and data. I also used Firebase Studio for vibe coding.

Try It Out

➡️ links.schächner.de

I built this because I was frustrated with the status quo. If you've had similar experiences with third-party link-in-bio tools going down or locking features behind paywalls, I'd love to hear your thoughts in the comments.

And if you try Linkbase, let me know what you think!

😮‍💨 I created my own face recognition system

techtech — Mon, 29 Sep 2025 16:38:12 +0000

Building a Privacy-First Face Recognition System That Actually Works 🔍

SchBenedikt / face

Local face detection + recognition (Pimeyes alternative)

🔍 Advanced Face Recognition Search System

🚀 State-of-the-art facial recognition system with intelligent search, quality filtering, and advanced analytics

📖 Documentation • ⚡ Quick Start • 🎯 Features • 🧠 AI Models • 🛠️ Installation • 🤝 Contributing

📚 Table of Contents

🚀 Quick Start

# Clone the repository
git clone https://github.com/SchBenedikt/face.git
cd face

# Install dependencies
pip install -r requirements.txt

# Set up the environment
python setup_env.py

# Launch the web interface
streamlit run app.py

🎉 That's it! Open your browser to http://localhost:8501 and start exploring.

🌟 What Makes This Special?

This isn't just another face recognition tool. It's a comprehensive facial intelligence platform that combines cutting-edge AI with practical usability:

🧠 Multi-Model AI…

View on GitHub

How I created a face recognition system that processes locally and respects user privacy

🚀 The Problem with Current Face Recognition

Most face recognition systems today have three major issues:

Privacy concerns - your photos go to the cloud
Black box algorithms - you can't see how they work
Limited accuracy - especially on diverse datasets

After working with computer vision for several years, I decided to build something different: a completely local, transparent, and highly accurate face recognition system.

🎯 What I Built

Meet the Advanced Face Recognition Search System - a comprehensive facial intelligence platform that:

🧠 Uses multi-model AI ensembles for 99%+ accuracy
🔒 Processes everything locally (GDPR compliant)
⚡ Handles thousands of images with optimized batch processing
🎯 Includes smart quality filtering to eliminate false positives
📊 Provides rich analytics (age, gender, emotion, ethnicity)

🔬 The Technical Deep Dive

Multi-Model Ensemble Architecture

Instead of relying on a single model, I implemented an ensemble approach using four state-of-the-art models:

Python Implementation:

class FaceRecognitionEngine:
    def __init__(self):
        # Ensemble of 4 Deep Learning models
        self.models = ["Facenet512", "ArcFace", "VGG-Face", "Facenet"]
        self.ensemble_weights = self._calculate_dynamic_weights()
        self.detection_backends = ["opencv", "mtcnn", "retinaface"]

    def extract_ensemble_embedding(self, image, face_location):
        """Extract embeddings using all models and fuse them intelligently"""
        embeddings = {}

        # Extract embeddings from each model
        for model_name in self.models:
            try:
                embedding = self._extract_single_embedding(
                    image, face_location, model_name
                )
                if embedding is not None:
                    embeddings[model_name] = embedding
            except Exception as e:
                logger.warning(f"Model {model_name} failed: {e}")

        # Adaptive weighted fusion based on image quality
        quality_metrics = self._analyze_image_quality(image)
        adaptive_weights = self._calculate_adaptive_weights(
            quality_metrics, embeddings
        )

        return self._weighted_ensemble_fusion(embeddings, adaptive_weights)

Why This Ensemble Approach Works

Each model has different strengths:

FaceNet512: Excellent for high-quality frontal faces
ArcFace: Superior performance on profile views and varying poses
VGG-Face: Robust against lighting variations
FaceNet: Fast processing for real-time applications

Advanced Similarity Calculation

Instead of simple cosine similarity, I implemented a multi-metric approach:

Multi-Metric Similarity Function:

def _calculate_comprehensive_similarity(self, embedding1, embedding2):
    """Multi-metric similarity calculation with 4 different algorithms"""
    # Normalize embeddings
    emb1_norm = embedding1 / (np.linalg.norm(embedding1) + 1e-8)
    emb2_norm = embedding2 / (np.linalg.norm(embedding2) + 1e-8)

    # Calculate multiple similarity metrics
    cosine_sim = np.dot(emb1_norm, emb2_norm)
    euclidean_sim = 1.0 / (1.0 + np.linalg.norm(emb1_norm - emb2_norm))
    manhattan_sim = 1.0 - (
        np.sum(np.abs(emb1_norm - emb2_norm)) / len(emb1_norm)
    )

    # Correlation similarity
    try:
        correlation = np.corrcoef(emb1_norm, emb2_norm)[0, 1]
        corr_sim = (
            (correlation + 1.0) / 2.0 if not np.isnan(correlation) else 0.0
        )
    except:
        corr_sim = 0.0

    # Weighted fusion of all metrics
    weights = {
        'cosine': 0.45, 
        'euclidean': 0.25, 
        'correlation': 0.15, 
        'manhattan': 0.15
    }

    primary_similarity = (
        cosine_sim * weights['cosine'] +
        euclidean_sim * weights['euclidean'] +
        corr_sim * weights['correlation'] +
        manhattan_sim * weights['manhattan']
    )

    return {
        'primary_similarity': primary_similarity,
        'confidence_score': 1.0 - np.std([
            cosine_sim, euclidean_sim, corr_sim
        ])
    }

🎨 The User Experience

I built the interface using Streamlit to make it accessible to non-technical users. The system currently works with static images only (JPG, PNG, BMP, WEBP formats) - no video processing capabilities yet.

1. Smart Face Detection

Image Upload and Processing:

def analyze_uploaded_image_for_faces(uploaded_file, max_results, similarity_threshold):
    """Analyze uploaded image and detect faces with quality assessment"""
    with st.spinner("🔍 Analyzing image and detecting faces..."):
        try:
            # Load and preprocess image
            query_image = load_and_preprocess_image(temp_path)

            # Multi-backend face detection for robustness
            face_locations = st.session_state.face_engine.detect_faces(query_image)

            if not face_locations:
                st.warning("""
                ❌ **No faces detected!** 

                **Tips for better results:**
                - Use an image with clearly visible face
                - Ensure the face is well-lit
                - Avoid images that are too small (minimum: 30x30 pixels per face)
                """)
                return

            # Store results for face selection
            st.session_state.detected_faces = {
                'image': query_image,
                'face_locations': face_locations,
                'max_results': max_results,
                'similarity_threshold': similarity_threshold
            }

            st.success(f"✅ {len(face_locations)} face(s) detected!")

        except Exception as e:
            st.error(f"❌ Error analyzing image: {str(e)}")

2. Quality-Based Filtering

One of the biggest challenges in face recognition is dealing with poor-quality images. I implemented comprehensive quality assessment:

def assess_image_quality(self, image, face_location):
    \"Comprehensive image quality assessment\"
    face_crop = self._extract_face_region(image, face_location)

    quality_scores = {}

    # Sharpness analysis using Laplacian variance
    gray = cv2.cvtColor(face_crop, cv2.COLOR_BGR2GRAY)
    laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
    quality_scores['sharpness'] = min(laplacian_var / 500.0, 1.0)

    # Contrast measurement
    contrast = gray.std()
    quality_scores['contrast'] = min(contrast / 64.0, 1.0)

    # Face size relative to image
    face_height = face_location[2] - face_location[0]
    face_width = face_location[1] - face_location[3]
    face_area = face_height * face_width
    quality_scores['size'] = min(face_area / 2500, 1.0)  # Optimal at 50x50+

    # Overall quality score
    overall_quality = np.mean(list(quality_scores.values()))

    return {
        'individual_scores': quality_scores,
        'overall_quality': overall_quality,
        'is_high_quality': overall_quality > 0.6
    }

📊 Performance Overview

The system shows promising results in testing environments:

Processing Capabilities:

Image Processing: Handles JPG, PNG, BMP, and WEBP formats
Batch Processing: Can process multiple images sequentially
Database Storage: Uses ChromaDB for vector storage and retrieval
Search Performance: Sub-second similarity search for moderate datasets
Memory Efficiency: Optimized for typical desktop/laptop hardware

Quality Factors:

Best Performance: High-quality frontal faces with good lighting
Moderate Performance: Profile views and varying poses
Challenging Conditions: Poor lighting and low resolution images
Hardware Dependent: Performance varies significantly with available RAM and CPU

🔒 Privacy-First Design

Privacy was a core design principle from day one:

1. Local-Only Processing

# No external API calls - everything runs locally
def process_face_recognition(image_path):
    """All processing happens on user's machine"""
    # Load models locally (downloaded once)
    face_engine = FaceRecognitionEngine()

    # Process image without any network requests
    faces = face_engine.detect_faces(cv2.imread(image_path))
    embeddings = face_engine.extract_embeddings(image_path, faces)

    # Store in local database only
    vector_store.add_faces(
        embeddings, 
        metadata={'image_path': image_path}
    )

    return len(faces)

2. GDPR Compliance Features

class PrivacyComplianceManager:
    \"\"\"Built-in GDPR compliance tools\"\"\"

    def exercise_right_of_erasure(self, data_subject_id):
        \"\"\"Complete data deletion on request\"\"\"
        # Remove from vector database
        deleted_faces = self._delete_face_embeddings(data_subject_id)

        # Remove from metadata
        deleted_metadata = self._delete_metadata(data_subject_id)

        # Secure memory wipe
        self._secure_memory_wipe(data_subject_id)

        return {
            'status': 'completed',
            'items_deleted': deleted_faces + deleted_metadata
        }

🚀 Real-World Applications

The system has been tested in several scenarios:

1. Photo Organization

Process 10,000+ family photos in under 30 minutes
Automatically group photos by person
Find specific people across years of photos

2. Historical Research

Digitize and organize historical photo collections
Track individuals across different time periods
Genealogical research applications

3. Content Creation

Organize media assets for video production
Find specific shots of people in large footage collections
Automated tagging for media libraries

🛠️ How to Get Started

Quick Setup (5 minutes)

# 1. Clone the repository
git clone https://github.com/SchBenedikt/face.git
cd face

# 2. Create virtual environment
python -m venv myenv
source myenv/bin/activate  # On Windows: myenv\\Scripts\\activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Initialize the system
python setup_env.py

# 5. Launch the web interface
streamlit run app.py

First Use

Upload Test Images: Add some photos to the data/images folder
Process Images: Use the batch processing feature to analyze all images
Search Faces: Upload a photo and find similar faces instantly
Explore Analytics: Try the facial analysis features

🔬 Technical Challenges Solved

1. Memory Optimization for Large Datasets

Working with 75,000+ face embeddings required careful memory management:

def batch_process_images(self, image_paths, batch_size=25):
    \"\"\"Memory-efficient batch processing\"\"\"
    for i in range(0, len(image_paths), batch_size):
        batch = image_paths[i:i + batch_size]

        # Process batch
        batch_results = []
        for image_path in batch:
            faces = self._process_single_image(image_path)
            batch_results.extend(faces)

        # Store batch results
        self.vector_store.add_batch(batch_results)

        # Clear memory
        gc.collect()

        yield len(batch_results)

2. Cross-Platform Compatibility

Ensuring the system works on Windows, macOS, and Linux:

def setup_cross_platform_dependencies():
    \"\"\"Handle platform-specific requirements\"\"\"
    if platform.system() == \"Windows\":
        # Windows-specific dlib installation
        install_windows_dlib()
    elif platform.system() == \"Darwin\":  # macOS
        # macOS-specific optimizations
        setup_macos_accelerate()
    else:  # Linux
        # Linux-specific CUDA setup
        setup_linux_cuda()

📈 What's Next?

I'm working on several exciting features:

1. Real-Time Processing

Live camera integration
Real-time face tracking
Instant similarity search

2. Mobile Applications

iOS/Android apps with local processing
Cross-device synchronization
Mobile-optimized models

3. Advanced Analytics

Emotion tracking over time
Age progression analysis
Demographic insights with bias detection

🤝 Join the Community

This project is completely open source, and I'd love your contributions:

🌟 Star the repo if you find it useful
🐛 Report issues to help improve the system
💡 Suggest features for future development
🔧 Submit PRs to contribute code

Ways to Contribute

Code Contributions: New features, bug fixes, optimizations
Documentation: Tutorials, examples, translations
Testing: Try it with your datasets and report results
Feedback: Share your use cases and experiences

🎯 Key Takeaways

Building this face recognition system taught me several important lessons:

Ensemble methods significantly improve accuracy over single models
Privacy-first design doesn't have to compromise functionality
Quality assessment is crucial for production systems
User experience matters as much as technical performance
Open source accelerates innovation and builds trust

📚 Resources & Links

GitHub Repository: SchBenedikt/face

Have you built similar systems? What challenges did you face? Share your experiences in the comments below!

This article was written by AI

I created my own AI search engine

techtech — Wed, 23 Apr 2025 20:06:24 +0000

Hello everyone 👋

SchBenedikt / search-engine

AI search engine

🚀 Search Engine

The matching search engine to my web crawler.

✨ Features

🌐 Modern 3D Interactive Landing Page with full-screen visualizations that dynamically adapt to different screen sizes
🤖 AI-Powered Answers providing instant responses with verified sources
📚 Knowledge Panels displaying relevant information from Wikipedia and trusted sources
⚡ Smart Search with real-time search speed display
📝 Website Summaries generated by AI to save reading time
🔍 Google Integration for comprehensive search results
🌙 Dark Mode Support for comfortable viewing in all lighting conditions
📱 Responsive Design optimized for all devices
🗄️ MongoDB Backend for efficient data operations

📄 Detailed Feature Overview

🌐 Modern 3D Landing Page

The search engine features a stunning 3D visualization on the landing page created with Three.js. The visualization creates an immersive experience with:

🖱️ Dynamic node connections that respond to mouse movements
📱 Responsive design that works across devices

🤖 AI-Powered Features

…

View on GitHub

Today, I’d like to introduce you to my AI-powered search engine. It’s completely free, available on GitHub, and can be self-hosted. There are tons of awesome features, which I’ll list below:

🤖 AI Features

🧠 AI Search Summary

Every time you search, an AI-generated summary is created to give you a quick overview of the topic.

💬 AI Website Chat

For every search result—whether from a local database or Google—the content of the website is fetched, and you can chat with it directly, since the AI has access to its content.

🖱️ Hover Summary

Hover over a search result to get a short summary of the website content—similar to the Arc Browser experience.

🔍 Search Results

Search results can come either from a local database using a web crawler or from Google’s Custom Search Engine (those are highlighted in blue).

Thanks to the Google integration, a sidebar provides keyword suggestions—just like in Google!

📚 Sidebar Features

The sidebar offers several helpful features:

🔁 Suggested keywords to expand your search
📘 Wikipedia preview if a matching article is found
💡 Stack Overflow integration makes it super easy for developers to look up problems and solutions directly
🧑‍💻 GitHub integration shows company or user profiles, including the latest 3 updated repositories

⭐ Special Features

🌤️ Weather

If you search for the weather, a weather overview will appear before the AI summary—complete with real-time data (the AI also has internet access).

💰 Crypto Prices

Crypto prices are shown in a similar way to the weather results—right at the top, for quick access.

How do you like my search engine?

I’d love to hear your feedback, comments, and reactions! 💬✨

macOS AI Agent

techtech — Wed, 09 Apr 2025 18:53:02 +0000

Building a Gemini AI Assistant for macOS

I created the first macOS AI-powered Agent:

Meet the AI-Agent, a native macOS application that integrates with Google's Gemini AI to provide a seamless assistant experience. This project is open-source, and we encourage you to test it, modify it, and contribute to its development.

SchBenedikt / ai-agent

Testing macOS AI Agent with Google Gemini Live Web API

Gemini Assistant macOS App

A native macOS application that connects to Google's Gemini AI. The app automatically accesses your camera and microphone to provide a seamless AI assistant experience

Features

Audio input through your microphone
Visual context through your camera
Text responses displayed in the app
Audio responses played through your speakers

Setup

Prerequisites

Python 3.8+
A Google Gemini API key

Installation

Install the required dependencies:

pip install google-generativeai opencv-python pyaudio pillow mss PyQt5 pynput python-dotenv pyinstaller

Set your Gemini API key as an environment variable (optional):
```
export GEMINI_API_KEY="your-api-key-here"
```
If not set as an environment variable, the app will ask for it on startup.

Building the macOS App

There are two ways to build the app:

Method 1: Using PyInstaller (Recommended)

PyInstaller creates a more reliable standalone application that better handles dependencies:

Make sure PyInstaller is installed:
```
pip install pyinstaller
```
Run the build process:
```
# First clean any previous builds
```
…

View on GitHub

What is AI-Agent?

The Gemini Assistant is a macOS application designed to:

Capture audio input through your microphone.
Use your camera for visual context.
Provide AI-powered responses via text.

The app leverages Google's Gemini AI for natural language understanding and response generation, making it a powerful tool for productivity and interaction.

Features

Audio Input: Speak to the assistant using your microphone.
Visual Context: The app uses your camera to gather additional context.
Text Responses: Get responses displayed in the app
Customizable: Modify the code to add new features or improve existing ones

How It Works

The application is built using Python and integrates several libraries:

PyQt5: For the user interface.
OpenCV: For camera access and visual processing.
PyAudio: For capturing and playing audio.
Google Generative AI: For natural language processing.
Python-dotenv: For managing environment variables.

The app uses a .env file to store your Google Gemini API key securely. If the file doesn't exist, the app will create one for you.

Getting Started

Prerequisites

Python 3.8 or higher
A Google Gemini API key

Installation

Clone the repository:

   git clone https://github.com/SchBenedikt/ai-agent.git
   cd ai-agent

Install the required dependencies:

   pip install -r requirements.txt

Set your Gemini API key in the .env file:

   echo "GEMINI_API_KEY=your-api-key" > .env

Running the App

To run the app directly without building:

python app.py

Building the App

You can build a standalone macOS application using PyInstaller:

pyinstaller gemini.spec

The app will be created in the dist folder as Gemini Assistant.app.

Contributing

We welcome contributions! Here are some ways you can help:

Test the App: Run the app and report any issues.
Improve the Code: Add new features or optimize existing ones.
Documentation: Help us improve the documentation.

Feedback

We'd love to hear your thoughts! Share your feedback, suggestions, or issues in the GitHub repository.

Conclusion

The Gemini Assistant is a powerful example of how AI can be integrated into everyday applications.

I hope you find this project as useful and enjoyable as it is!

Thanks for reading,
techtech

What do you think?

techtech — Wed, 19 Feb 2025 15:12:01 +0000

I created my own search engine

techtech ・ Feb 19

#webdev #python #mongodb #bootstrap

[Boost]

techtech — Wed, 19 Feb 2025 15:11:28 +0000

I created my own search engine

techtech ・ Feb 19

#webdev #python #mongodb #bootstrap

I created my own search engine

techtech — Wed, 19 Feb 2025 15:07:11 +0000

Hello everyone,

I'm excited to share some new features and improvements in my custom search engine project. This search engine is designed to work seamlessly with my web crawler, providing efficient and accurate search results. Let's dive into the latest updates!

@aminnairi has already asked why I don't use a NoSQL database. The software and the web crawler now use mongoDB as a noSQL database, which leads to faster search results.

The AI is still from Llama, now llama-3.3-70b.
In the search results, you can right-click to display a preview of the website. In addition, the favicons are only loaded when all search results have been successfully loaded. These are stored locally temporarily so that they do not have to be retrieved again each time.

SchBenedikt / search-engine

The matching search engine to my web crawler.

search-engine

The matching search engine to my web crawler.

The Docker image is currently not working https://hub.docker.com/r/schbenedikt/search

Features

Display of the search speed.
Ask AI for help.
Uses MongoDB for database operations.

Docker Instructions

Building the Docker Image

To build the Docker image, run the following command in the root directory of the repository:

docker build -t ghcr.io/schbenedikt/search-engine:latest .

Running the Docker Container

To run the Docker container, use the following command:

docker run -p 5560:5560 ghcr.io/schbenedikt/search-engine:latest

This will start the Flask application using Gunicorn as the WSGI server, and it will be accessible at http://localhost:5560.

Pulling the Docker Image

The Docker image is publicly accessible. To pull the Docker image from GitHub Container Registry, use the following command:

docker pull ghcr.io/schbenedikt/search-engine:latest

Note

Ensure that the tags field in the GitHub Actions workflow is correctly set to ghcr.io/schbenedikt/search-engine:latest to avoid multiple packages.

Running with Docker Compose

To run…

View on GitHub

The databases can now be managed via the settings page. There is now also the option to add multiple databases at the same time. When a search is made, the system checks whether there are websites that are saved multiple times so that the same website is not displayed multiple times.

This brings us to the filter functions:
The meta data is used to retrieve the various website types, which can then be used to filter. However, since there may be a "website" type and a "website" type, these can be combined into a "all websites" type.

SchBenedikt / web-crawler

A simple web crawler using Python that stores the metadata of each web page in a database.

web-crawler

A simple web crawler using Python that stores the metadata and main content of each web page in a database.

Purpose and Functionality

The web crawler is designed to crawl web pages starting from a base URL, extract metadata such as title, description, image, locale, type, and main content, and store this information in a MongoDB database. The crawler can handle multiple levels of depth and respects the robots.txt rules of the websites it visits.

Dependencies

The project requires the following dependencies:

requests
beautifulsoup4
pymongo

You can install the dependencies using the following command:

pip install -r requirements.txt

Setting Up and Running the Web Crawler

Clone the repository:

git clone https://github.com/schBenedikt/web-crawler.git
cd web-crawler

Install the dependencies:

pip install -r requirements.txt

Ensure that MongoDB is running on your local machine. The web crawler connects to MongoDB at localhost:27017 and uses a database named search_engine.
Run the web crawler:

python

…

View on GitHub

Instrument Sans is now used as the default font and there is also a dark mode that is automatically activated when the system is also in dark mode.

What do you think of the project?
Feel free to write it in the comments!

🔊 New Open Source Podcast

techtech — Mon, 10 Feb 2025 17:43:00 +0000

Hello dev.to community!

Finally a new post from me.
I would just like to introduce "my" podcast ("Open Source Software") here.
What? Another new podcast?
Yes. And this time it's very special: This podcast was generated solely by an AI. And the result? Pretty impressive.
The first episode is generally just about what open source actually is. But you all know that already.

In the next episodes I want to go into a little more detail about trends or general news in the development & open source scene.

But how often do you want new episodes?

Feel free to write your opinion about the podcast in the comments!

I would also be happy if you listen to the podcast and share it!

Thank you very much and have fun!

I created my own search engine

techtech — Sun, 09 Jun 2024 06:42:44 +0000

NEW POST:

I created my own search engine

techtech ・ Feb 19

#webdev #python #mongodb #bootstrap

I have created my own search engine and I'll tell you how it works.

First of all, I created my own web crawler. It runs on Python and stores various meta data in a mysql database.

SchBenedikt / web-crawler

A simple web crawler using Python that stores the metadata of each web page in a database.

web-crawler

A simple web crawler using Python that stores the metadata and main content of each web page in a database.

Purpose and Functionality

Dependencies

The project requires the following dependencies:

requests
beautifulsoup4
pymongo

You can install the dependencies using the following command:

pip install -r requirements.txt

Setting Up and Running the Web Crawler

Clone the repository:

git clone https://github.com/schBenedikt/web-crawler.git
cd web-crawler

Install the dependencies:

pip install -r requirements.txt

Ensure that MongoDB is running on your local machine. The web crawler connects to MongoDB at localhost:27017 and uses a database named search_engine.
Run the web crawler:

python

…

View on GitHub

The search engine, which I created with Bootstrap, then retrieves the results from mySQL. The bottom right always shows how long the query took.

SchBenedikt / search-engine

The matching search engine to my web crawler.

search-engine

The matching search engine to my web crawler.

The Docker image is currently not working https://hub.docker.com/r/schbenedikt/search

Features

Display of the search speed.
Ask AI for help.
Uses MongoDB for database operations.

Docker Instructions

Building the Docker Image

To build the Docker image, run the following command in the root directory of the repository:

docker build -t ghcr.io/schbenedikt/search-engine:latest .

Running the Docker Container

To run the Docker container, use the following command:

docker run -p 5560:5560 ghcr.io/schbenedikt/search-engine:latest

This will start the Flask application using Gunicorn as the WSGI server, and it will be accessible at http://localhost:5560.

Pulling the Docker Image

The Docker image is publicly accessible. To pull the Docker image from GitHub Container Registry, use the following command:

docker pull ghcr.io/schbenedikt/search-engine:latest

Note

Ensure that the tags field in the GitHub Actions workflow is correctly set to ghcr.io/schbenedikt/search-engine:latest to avoid multiple packages.

Running with Docker Compose

To run…

View on GitHub

Please note that no robots.txt files are currently taken into account, which is why you cannot simply crawl every page.

What do you think of the project?

Feel free to write it in the comments!

How to install Ghost CMS

techtech — Wed, 06 Sep 2023 06:47:12 +0000

Ghost is a modern content management system - this means that you can host websites with it just like with WordPress. However, since it was only founded in 2013, you can imagine that there are not that many plugins & themes here. But for some themes you have to dig deep into your pocket and sometimes pay more than 100 euros for it.
Today we show you how you can easily install this with one command via Docker.

We would appreciate a like :heart and a comment!
Feel free to visit our Ghost page and register for exclusive newsletters to find out everything!
(self-hosted.schächner.de)

But to do that, you first need Docker and then Docker-Compose.

sudo apt update
sudo apt upgrade
sudo apt install docker.io
sudo apt install docker-compose

Then we have to create a docker-compose.yml file – no matter where.sudo nano docker-compose.yml

This contains the following content. Note that the password and username should be changed for security reasons - the port can remain the same.
But what you have to change are the mail settings with which you then send e-mails.

version: '3.1'

services:

  ghost:
    image: ghost:latest
    restart: always
    ports:
      - 8089:2368
    environment:

      database__client: mysql
      database__connection__host: db
      database__connection__user: root
      database__connection__password: Schächner&Tech
      database__connection__database: ghost
      url: http://localhost
      mail__from: "'Schächner' <server@schächner.de>"
      mail__transport: "SMTP"
      mail__options__host: "smtp.strato.de"
      mail__options__port: 587
      mail__options__auth__user: "your-mail"
      mail__options__auth__pass: "your-password"

  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: Schächner&Tech

After saving that with ctrl+o and exiting with ctrl+x, we need our actual command:
sudo docker-compose up -d

That all starts the container.
If we now wait about 2 minutes and then open our IP address, then you have to specify the port after the IP address:
XXX.XXX.XXX.XX:8089

The website should be visible here.
To still be able to access it as an admin, you have to go to the following URL:
XXX.XXX.XXX.XX:8089/ghost

Here you create an admin account with which you can then write posts.
Do you have any questions, suggestions or requests?
Feel free to write everything in the comments!
Best regards and see you next time!