Forem: hayerhans

Free Model Context Protocol (MCP) Course

hayerhans — Wed, 16 Jul 2025 08:44:24 +0000

🚀 Just launched: My free MCP (Model Context Protocol) course on Udemy
👉 https://www.udemy.com/course/model-context-protocol-free/

While many courses charge $50+ for just 1 hour of content, I've made this course completely free, packed with practical insights and real-world examples.

If you're exploring AI agent architectures or want to level up your LLM stack knowledge, this course is for you.
🧠 Built for devs, explained simply.

🙏 Support my work by enrolling, leaving a review, or sharing it—it helps boost visibility so more engineers can benefit.

What is llms.txt?

hayerhans — Thu, 22 May 2025 08:17:23 +0000

What is llms.txt?

Watch the full setup demonstration →

llms.txt works like a sitemap for websites, but designed for AI systems. It provides large language models with a structured overview of concepts and links to detailed information, allowing the AI to make targeted fetch calls when it needs more specific details.

How It Works

Using the FastMCP project as an example, their llms.txt file contains:

Overview of all key concepts
Links to detailed documentation
Structured format that LLMs can easily parse

When an LLM needs more information, it can fetch specific URLs from the llms.txt file rather than guessing or hallucinating.

Setting Up MCP Doc Server

The LangChain team created MCP Doc - an MCP server that serves llms.txt files to AI systems. Here's the detailed setup process:

Step 1: Start the MCP Doc Server

The correct command to start the mcpdoc server is:

uvx --from mcpdoc mcpdoc \
    --urls "LangGraph:https://langchain-ai.github.io/langgraph/llms.txt" "LangChain:https://python.langchain.com/llms.txt" \
    --transport sse \
    --port 8082 \
    --host localhost

Command Breakdown:

uvx: Python package runner (similar to npx for Node.js)
--urls: Specify multiple llms.txt sources with labels
--transport sse: Server-Sent Events transport method
--port 8082: Local port for the MCP server
--host localhost: Server host configuration

Step 2: Configure in VS Code/Cline

In VS Code with Cline, navigate to the server configuration:

Click the server symbol in Cline
Select "Install"
Click "Configure MCP servers"

Step 3: Add MCP Server Configuration

Add this configuration to connect to your running mcpdoc server:

{
  "mcpServers": {
    "docs": {
      "command": "uvx",
      "args": [
        "--from", "mcpdoc", "mcpdoc",
        "--urls", "FastMCP:https://gofastmcp.com/llms.txt",
        "--transport", "sse",
        "--port", "8082",
        "--host", "localhost"
      ]
    }
  }
}

Configuration Details:

Multiple sources: Add as many "Label:URL" pairs as needed
Port matching: Ensure port matches your running server
Labels: Use descriptive names for each documentation source

Step 4: Restart and Verify

After configuration:

Restart your MCP servers
Verify the "docs MCP" server appears in your available tools
Test with a query that requires current documentation

Real-World Demo: Dynamic Documentation Fetching

Here's what actually happens when you ask for help with MCP development:

The Query

"Help with dynamic resources in MCP use"

The AI's Process

Lists available sources: Uses list_doc_sources to see what llms.txt files are available
Fetches overview: Makes fetch_docs call to get the complete llms.txt content
Identifies specific needs: Recognizes it needs more detail on "resources"
Makes targeted fetch: Calls the specific resources documentation URL
Provides accurate answer: Uses the fetched information for correct implementation

The Result

No hallucination. Perfect implementation with current best practices.

Multiple Source Configuration Example

You can configure multiple llms.txt sources for comprehensive coverage:

uvx --from mcpdoc mcpdoc \
    --urls \
        "LangGraph:https://langchain-ai.github.io/langgraph/llms.txt" \
        "LangChain:https://python.langchain.com/llms.txt" \
        "FastMCP:https://gofastmcp.com/llms.txt" \
        "YourProject:https://yourproject.com/llms.txt" \
    --transport sse \
    --port 8082 \
    --host localhost

This gives your AI assistant access to documentation from multiple projects simultaneously.

Why This Approach Works Better

Traditional AI Development Issues

Outdated training data
Deprecated API references
Hallucinated implementation details

With llms.txt + MCP Doc

Current information: Always references latest documentation
Targeted fetching: Gets exactly the information needed
No guesswork: AI works with actual current docs, not assumptions

Key Benefits

Free: Unlike some context tools, this approach costs nothing
Multiple sources: Can integrate multiple llms.txt files simultaneously
Current information: Always references the latest documentation
Structured approach: Systematic rather than guessing
IDE integration: Works seamlessly with VS Code, Cursor, Windsurf

Use Cases

Perfect for:

MCP server development (as demonstrated)
Framework-specific development where APIs change frequently
Multi-project development requiring different documentation sources
Team environments where everyone needs access to current docs

Thanks for reading ! Have a question? Reach out to me or comment below

🔗 CONNECT:
Substack: https://substack.com/@jhayer93
Discord Community: https://discord.gg/2wSR6GPgB5
LinkedIn: https://www.linkedin.com/in/johannes-hayer-b8253a294/

smolagents: The Simplest Way to Build Powerful AI Agents

hayerhans — Wed, 09 Apr 2025 08:11:36 +0000

Ever wonder how language models can search the web but struggle to run a simple calculation accurately? Or how they can analyze PDFs but can't make an API call? Welcome to the gap between traditional language models and AI agents.

Traditional LLMs are impressive but passive - they generate text based on patterns learned during training. AI agents, on the other hand, can take action in the world. They can search the web, call APIs, execute code, and interact with databases - all to achieve specific goals.

Enter smolagents: a lightweight library that strips AI agent development down to its essentials.

The Brain and Body Architecture

As shown in the diagram above, an AI agent consists of two fundamental components:

The Brain: An LLM that handles reasoning and planning, making decisions about which actions to take (hence often called the "Router")
The Body: The agent's means of interacting with its environment - defined by the tools and actions available to it

smolagents brilliantly implements this architecture with minimal overhead. The entire library is around 1,000 lines of code, embodying the "keep it simple" philosophy that building powerful AI agents shouldn't require complex architecture.

From Workflows to True Agents

Where does smolagents fit in the broader landscape of AI development patterns?

As this diagram illustrates, there's a spectrum:

On the left, we have workflows where the developer pre-defines the paths
In the middle, the LLM has some control but within limited options
On the right, true agents that direct their own actions based on environmental feedback

smolagents leans toward the right of this spectrum, enabling you to build agents that can truly adapt to circumstances and take appropriate actions.

Creating Your First Agent in Three Steps

Here's how simple it is to create a basic agent with smolagents:

from smolagents.agent import CodeAgent
from smolagents.model import HfApiModel

# 1. Initialize a model
model = HfApiModel(model_id="llama3/llama-3-8b-instruct")

# 2. Create an agent
agent = CodeAgent(model=model, tools=[])

# 3. Run the agent
response = agent.run("Calculate the 50th Fibonacci number")

That's it! This agent can already solve mathematical problems by generating and executing Python code. But the real power comes when you add custom tools.

The Magic of Custom Tools

smolagents makes creating custom tools refreshingly straightforward:

from smolagents.tool import tool

@tool("Get weather data for a city")
def get_weather_data(city: str):
    """
    Returns weather data for a given city.

    Args:
        city: The name of the city (e.g., New York, London, Tokyo)

    Returns:
        A dictionary containing weather data
    """
    # Implementation here...
    pass

Just add the @tool decorator to any Python function, provide good documentation, and your agent can now use this capability.

Code-First: LLMs Doing What They Do Best

smolagents uses a code-first approach instead of requiring JSON formats for actions. When your agent needs to analyze weather patterns across multiple cities, it might generate code like:

# Get weather for multiple cities
cities = ["Tokyo", "New York", "London"]
data = {}

for city in cities:
    data[city] = get_weather_data(city)

# Calculate average temperatures
avg_temps = {city: sum(info["temperatures"])/len(info["temperatures"]) 
             for city, info in data.items()}

# Find the warmest city
warmest_city = max(avg_temps, key=avg_temps.get)
print(f"The warmest city is {warmest_city} with an average of {avg_temps[warmest_city]:.1f}°C")

This is more natural for LLMs (which are trained extensively on code) and more powerful for solving complex problems.

When to Use smolagents

smolagents is perfect for:

Rapid prototyping of AI agents
Projects requiring custom domain-specific tools
When you need to switch between different LLM providers
Building systems that need to interact with their environment
When simplicity and readability matter more than complex architecture

However, for highly regulated environments or production systems requiring extensive monitoring, you might need additional infrastructure around your smolagents implementation.

Getting Started Today

Ready to build your first AI agent? Installation is straightforward:

pip install smolagents

Then you can quickly set up a model, define your tools, build your agent, and start interacting with it.

Whether you're building a personal assistant, a data analysis tool, or exploring complex multi-agent systems, smolagents offers a clean, intuitive library to bring your ideas to life.

Take Your Agent Development Skills to the Next Level

If you're ready to dive deeper into the world of AI agents, check out the comprehensive smolagents course at ai-in-a-shell.com. The free course covers everything from basic agent development to advanced multi-agent systems, custom tool creation, and production monitoring.

Web Automation in Plain English: Browser Use Changes Everything

hayerhans — Tue, 11 Feb 2025 20:40:20 +0000

Introduction

Hey everyone! Today we're diving into Browser Use, an incredible new library that's revolutionizing web automation. If you've ever struggled with Selenium or Playwright, dealing with selectors and timeouts, you're going to love this. Let's build something cool together!

Prefer video content? Check out my detailed walkthrough on YouTube: https://youtu.be/RsGTT7J7Po8

Setup Section

First, let's get our environment ready. I'll walk you through this step by step:

Create a fresh project folder and open your favorite IDE
Install UV - it's a super fast alternative to pip

curl -LsSf https://astral.sh/uv/install.sh | sh

Create a virtual environment with Python 3.11 (Browser Use requirement):

uv venv --python 3.11
source .venv/bin/activate

Install Browser Use and Playwright:

uv pip install browser-use
playwright install

Creating Our First Agent

Let's write our first Browser Use agent. Here's the minimal code you need:

from browser_use import Agent
from langchain_openai import ChatOpenAI

agent = Agent(
    task="Search for latest news about AI",
    llm=ChatOpenAI(model="gpt-4o"),
)

What's cool here is that we only need two main parameters:

task: Just tell it what you want to do in plain English
llm: Specify which language model to use

Advanced Configuration

Now, let's look at some powerful features. Browser Use gives us tons of configuration options:

agent = Agent(
    task="your task",
    llm=llm,
    controller=custom_controller,  # For custom tool calling
    use_vision=True,              # Enable vision capabilities
    save_conversation_path="logs/conversation.json"  # Save chat logs
)

The use_vision parameter is particularly interesting - it lets your agent actually see and understand what's on the webpage. Just keep in mind that for GPT-4o, each image processed costs about 800-1000 tokens (roughly $0.002 USD).

Working with Browser Sessions

One of the coolest features is the ability to connect to your existing Chrome instance. This is super helpful for situations where you need to be logged in. Here's how:

from browser_use import Agent, Browser

# Create and reuse a browser instance
browser = Browser()
agent = Agent(
    task=task1,
    llm=llm,
    browser=browser  # Browser instance will be reused
)

await agent.run()

# Don't forget to close when done
await browser.close()

Structured Output

If you need structured data, Browser Use has you covered. You can define custom output formats using Pydantic:

from pydantic import BaseModel

class Post(BaseModel):
    post_title: str
    post_url: str
    num_comments: int
    hours_since_post: int

class Posts(BaseModel):
    posts: List[Post]

controller = Controller(output_model=Posts)

Getting Results and History

After running your agent, you get access to tons of useful information:

history = await agent.run()

# Access various types of information
urls = history.urls()              # URLs visited
screenshots = history.screenshots()       # Screenshot paths
actions = history.action_names()      # Actions taken
content = history.extracted_content() # Extracted data
errors = history.errors()           # Any errors
model_actions = history.model_actions()     # All actions with parameters

Bonus: Using a Planner Model

For complex tasks, you can even use a separate model for high-level planning:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model='gpt-4o')
planner_llm = ChatOpenAI(model='o3-mini')

agent = Agent(
    task="your task",
    llm=llm,
    planner_llm=planner_llm,           # Planning model
    use_vision_for_planner=False,      # Disable vision for planner
    planner_interval=4                 # Plan every 4 steps
)

This setup lets you use a smaller, cheaper model for planning while keeping the powerful GPT-4o for execution.

Closing

That's it for today's tutorial! We've covered everything from basic setup to advanced features like browser session management and structured output. Drop a comment below if you'd like to see more Browser Use tutorials, maybe something about custom functions or system prompts?

StarSense - new way of interacting with repos

hayerhans — Sun, 10 Nov 2024 13:10:29 +0000

This is a submission for the Open Source AI Challenge with pgai and Ollama

What I Built

I built StarSense, an intelligent chat interface that helps developers easily search and discover their starred GitHub repositories using natural language. The project leverages RAG (Retrieval-Augmented Generation) technology to create a seamless conversation experience with your GitHub stars.

StarSense automatically processes your starred repositories by:

Authenticating with GitHub via OAuth
Fetching all starred repositories
Extracting and processing README content
Storing repository information in PostgreSQL
Generating embeddings using pgai vectorizer
Enabling natural language queries using vector similarity search

Demo/Repo

Repo: https://github.com/XamHans/starsense
Video: https://youtu.be/Uf1uzI0e3jM

The application features a clean chat interface where users can interact with their starred repositories naturally:

The project utilizes a robust architecture integrating Timescale, pgai, and Ollama:

Tools Used

Frontend

Next.js 14: Latest version of the React framework for building the web interface
TypeScript: For type-safe code
TailwindCSS: For styling and responsive design
NextAuth.js: Handling GitHub OAuth authentication
WebSocket Client: Real-time updates during repository ingestion

Backend

FastAPI: Modern Python web framework for building the API
WebSocket: Real-time connection for providing ingest phase status updates
Poetry: Python dependency management

AI and Vector Search

pgai Vectorizer: Implemented to generate embeddings for repository content using the following configuration:

SELECT ai.create_vectorizer(
  'public.repositories'::regclass,
  embedding=>ai.embedding_openai('text-embedding-3-small', 1536, api_key_name=>'OPENAI_API_KEY'),
  chunking=>ai.chunking_recursive_character_text_splitter('readme'),
  formatting=>ai.formatting_python_template('name: $name url: $url content: $chunk')
);

AI Extensions: The project utilizes multiple Timescale extensions:
- ai extension for core AI functionality
- vector extension for similarity search
- vectorscale for scalable vector operations
Ollama: Used for generating natural language responses based on retrieved repository content, specifically utilizing the llama3 model.

Database & Infrastructure

TimescaleDB: PostgreSQL-based database with vector search capabilities
GitHub API: For fetching starred repositories and README content

Final Thoughts

Building StarSense has been an exciting journey in combining modern AI technologies with practical developer tools. The integration of pgai's vectorizer with Ollama's language models creates a powerful synergy that makes repository discovery feel natural and intuitive.

Some key learnings and highlights:

The pgai vectorizer dramatically simplified the embedding process by:
- Automatically handling document chunking and preprocessing
- Managing embedding generation and storage
- Eliminating the need for separate embedding infrastructure
- Seamlessly integrating with existing PostgreSQL workflows
Timescale's AI extensions provided a robust foundation for vector operations
Ollama's open-source models offered great performance for natural language generation
The WebSocket implementation enabled real-time feedback during the repository ingestion process
The combination of Next.js 14 and FastAPI created a performant and developer-friendly stack

This submission qualifies for the following prize categories:

Open-source Models from Ollama (utilizing llama3)
Vectorizer Vibe (implementing pgai vectorizer)
All the Extensions (using ai, vector, and vectorscale extensions)

Machine Learning for Web devs

hayerhans — Thu, 29 Aug 2024 10:04:12 +0000

When I started my career as a Software Engineer, I felt comfortable in the realm of web development. Whenever I heard about someone working in AI or ML, I couldn't help but admire them. I assumed these people possessed a deep understanding of mathematics and statistics that enabled them to do such impressive work. However, with the rise of ChatGPT and its incredible capabilities, I decided to dig deeper into the topic. What I discovered was eye-opening: you don't need to be a genius to work with ML or AI!

Like any discipline, there are multiple sub-domains within ML and AI that require different skill sets. As an engineer and developer, I approach this field from the perspective of how to integrate it into modern web applications. I recently passed the Azure AI-900 certification, and I realized that my fellow developers could benefit from this knowledge too. So, let's explore what ML is all about!

What is Machine Learning?

At its core, Machine Learning (ML) is a subset of artificial intelligence that focuses on creating algorithms and models that can learn from data. Unlike traditional programming where we explicitly define rules, ML algorithms learn patterns and relationships from data to make predictions or decisions.

To put it in mathematical terms, ML is about learning a function f(x) = y, where:

x represents the input data (features)
y represents the output (predictions or labels)
f is the learned function or model

The key difference from traditional programming is that the function f is not explicitly coded but learned from data during a process called training.

Key Terminology

Before we dive deeper, let's familiarize ourselves with some essential terms:

Features: These are the observed attributes or input data. For example, if we're predicting house prices, features might include the size of the house, its location, and the number of bedrooms.
Labels: These are the outcomes that the model tries to predict. In our house price example, the label would be the actual price of the house.

Types of Machine Learning

There are several types of machine learning, but we'll focus on the two main categories:

Supervised Learning
- Uses training data that includes both feature values and known label values
- Format: [X1, X2, X3], Y
- Used when you have historical data with known outcomes
- Example: Predicting house prices based on features like location, size, etc.
Unsupervised Learning
- Uses training data that includes only feature values, without labels
- Format: [X1, X2, X3]
- Used to find patterns or relationships in data without predefined outcomes
- Example: Grouping similar customers based on demographics and behavior

The Training Process

Now that we understand the basics, let's look at how ML models are actually trained

Data Collection: Gather a large dataset relevant to your problem.
Data Preprocessing: Clean and prepare your data, handling missing values and outliers.
Split the Data: Divide your dataset into:
- Training set: Used to teach the model (typically 70-80% of the data)
- Validation set: Used to tune the model and prevent overfitting (typically 10-15%)
- Test set: Used to evaluate the final model performance (typically 10-15%)
Choose an Algorithm: Select an ML algorithm appropriate for your problem. The beauty is that these algorithms are often interchangeable, allowing you to experiment with different approaches.
Train the Model: Feed the training data into your chosen algorithm, allowing it to learn the patterns in the data.
Validate and Tune: Use the validation set to fine-tune your model's parameters and prevent overfitting.
Test and Evaluate: Finally, use the test set to assess how well your model generalizes to new, unseen data.

Want to Learn More?

I'm excited to announce that I'm creating a free course on Azure AI-900! If you're interested in diving deeper into AI and ML, particularly within the Azure ecosystem, this course is perfect for you.

Thanks for reading, and stay tuned for the next post where we'll dive into computer vision capabilities. The world of AI and ML is vast and exciting, and I can't wait to explore it further with you!

How to get up & running a LLM locally - in 5 minutes

hayerhans — Sat, 23 Mar 2024 14:51:31 +0000

Video Version:
https://youtube.com/shorts/y0NWVUsfLiU?si=x16bKEoHLfk87nC2

What is Ollama?

It's a lightweight framework designed for those who wish to experiment with, customize, and deploy large language models without the hassle of cloud platforms. With Ollama, the power of AI is distilled into a simple, local package, allowing developers and hobbyists alike to explore the vast capabilities of machine learning models.

Setting Up Ollama: A Step-by-Step Approach

First download ollama for your OS here:
https://ollama.com/download

Second run the model you want with:

ollama run llama2

Model library

Ollama supports a list of models available on ollama.com/library

Here are some example models that can be downloaded:

Model	Parameters	Size	Download Command
Llama 2	7B	3.8GB	`ollama run llama2`
Mistral	7B	4.1GB	`ollama run mistral`
Dolphin Phi	2.7B	1.6GB	`ollama run dolphin-phi`
Phi-2	2.7B	1.7GB	`ollama run phi`
Neural Chat	7B	4.1GB	`ollama run neural-chat`
Starling	7B	4.1GB	`ollama run starling-lm`
Code Llama	7B	3.8GB	`ollama run codellama`
Llama 2 Uncensored	7B	3.8GB	`ollama run llama2-uncensored`
Llama 2 13B	13B	7.3GB	`ollama run llama2:13b`
Llama 2 70B	70B	39GB	`ollama run llama2:70b`
Orca Mini	3B	1.9GB	`ollama run orca-mini`
Vicuna	7B	3.8GB	`ollama run vicuna`
LLaVA	7B	4.5GB	`ollama run llava`
Gemma	2B	1.4GB	`ollama run gemma:2b`
Gemma	7B	4.8GB	`ollama run gemma:7b`

Memory Requirements:
Keep in mind, running these models isn't light on resources. Ensure you have at least 8 GB of RAM for 7B models, and more for the larger ones, to keep your AI running smoothly.

Customization

With Ollama, you're not just running models; you're tailoring them. Import models with ease and customize prompts to fit your specific needs. Fancy a model that responds as Mario? Ollama makes it possible with simple command lines:

Customize a prompt

Models from the Ollama library can be customized with a prompt. For example, to customize the llama2 model:

ollama pull llama2

Create a Modelfile:

FROM llama2


# set the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1

# set the system message

SYSTEM """
You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
"""

Next, create and run the model:

ollama create mario -f ./Modelfile ollama run mario

hi
Hello! It's your friend Mario.

If you liked this content also have a look at my YouTube channel

This is why Voiceflow makes a winning in the AI Automation area

hayerhans — Tue, 10 Oct 2023 06:12:22 +0000

What is Voiceflow and why does it make a winning?

Voiceflow is a powerful platform that excels in the field of AI Automation. It offers a wide range of tools and features that enable users to create sophisticated conversational experiences with ease. Next to Voiceflows they are other platforms like BotPress and Rasa that are also great for creating chatbots. But what makes Voiceflow so special? Well it's the templates that they provide.

What are Voiceflow templates?

Voiceflow templates are powerful tools that can significantly improve the speed and efficiency of building chatbots. By utilizing these templates, you can learn from other creators and leverage their expertise to create sophisticated conversational experiences.

With Voiceflow templates, you can explore different use cases and industries, such as advanced AI FAQ support bots, AI lead generation, personal productivity assistants, language learning chatbots and more.

By starting with a template, you can save time and effort in the development process. Here are 5 templates that you can use for FREE!

💡 Are you an AI bot builder looking for more gigs? Or are you an agency struggling to find qualified technical talent? If so, you're not alone.

That's where a reverse job platform for AI bot builders comes in. This type of platform allows bot builders to create profiles and showcase their skills and experience. Agencies can then browse these profiles and contact bot builders directly to discuss potential projects.

Pre-sign up now: https://botdevs.io

5 free templates to enhance your voiceflow bot creation process.

*Template 1: Advanced AI FAQ Support Bot*
- Description: This template enables you to create an AI-powered chatbot that offers advanced support by utilizing your own documentation. It utilizes the Knowledge Base feature to extract information from websites or documents, facilitating dynamic conversations. The bot also uses sentiment analysis to assess user responses and provide appropriate replies, drawing information from your data sources.
- Get Started: Start with Template
*Template 2: AI Lead Generation*
- Description: Learn how to design a conversational experience and automate the process of sending lead information to a Google spreadsheet. This tutorial is created by Vinera AI, a company that empowers growth through time-saving AI automation. Vinera AI partners with businesses to maximize efficiency by providing AI-powered tools such as chatbots and automations, helping companies save valuable time and resources.
- Get Started: Start with Template
*Template 3: Knowledge about your Shopify products*
- Description:This is a full e-commerce chatbot template that includes components for creating a custom knowledge questionnaire, collecting leads with Zapier, and connecting with Shopify's API. How cool is that? You can ask questions about your products and the AI is giving an answer based on your product knowledge
- Get Started: Start with Template
*Template 4: Intelligent AI buddy with conversational memory*
- Description: Learn how to use long term memory in Voiceflow to create an intelligent human-like AI buddy. This template will guide you through building a chatbot with a conversational memory that can remember user preferences, previous interactions, and provide personalized responses.
- Get Started: Start with Template
*Template 5: Survey Feedback AI*
- Description: This tutorial uses AI and sentiment analysis to assess a user's satisfaction through a feedback survey. Based on their response, the chatbot will respond accordingly.
- Get Started: Start with Template

If you need help with any of these templates, visit the VoiceFlow Discord community to get help: https://discord.com/invite/JXRbEv7nD2

How to get text from any YT video | Free transcribe program 🖹

hayerhans — Fri, 11 Aug 2023 08:24:34 +0000

Check out the video tutorial:
https://www.youtube.com/watch?v=b9oyBebJCK0

Looking to transcribe text from YouTube videos effortlessly? In this step-by-step tutorial, I will guide you through the process of setting up Video2Text on your local computer for a seamless text extraction experience.

🔗 Get started with Video2Text:

📂 Clone the Video2Text repository: git clone https://github.com/XamHans/video-2-text.git

📁 Navigate to the 'webserver' directory

🔧 Install required dependencies: pip3 install -r requirements.txt

➡️ If you encounter a 'streamlit' recognition error, execute this command in your terminal: export PATH="$HOME/.local/bin:$PATH"

🚀 Launch the Video2Text app: streamlit run app.py

🌐 Access the Video2Text interface: Open your browser and go to http://localhost:8501

🆓 Video2Text is free to use and open-source:
GitHub Repository: https://github.com/XamHans/video-2-text.git

🔗 Helpful Links:
PyTube Documentation: https://pytube.io/en/latest/
OpenAI Whisper Documentation: https://github.com/openai/whisper

Thanks for reading

Johannes

🤖 How to Integrate BotPress Bot into Next.js 13 | 🚀 Step-by-Step Guide!

hayerhans — Wed, 09 Aug 2023 20:48:42 +0000

🍕 Get the code here:

https://github.com/XamHans/botpress-nextjs

⛔ Make sure that your bot is deployed!

📹 Video Tutorial:
https://www.youtube.com/watch?v=zUTFqEeA0NI&ab_channel=HayerHans

📚 Key Steps Covered:

🔗 Clone the repo with: git clone https://github.com/XamHans/botpress-nextjs.git
📁 cd into the folder and install the dependencies with yarn install
💻 start the application with yarn dev
📝 get the Botpress Webchat Snippet from botpress website

🧩 Navigate to the layout.tsx file. In the head section use the Script Component to init botpress



<Script
          src="https://cdn.botpress.cloud/webchat/v0/inject.js"
          onLoad={() => {
            initBotpress();
          }}
        />



const initBotpress = () => {
    window.botpressWebChat.init({
      composerPlaceholder: "Chat with bot",
      botConversationDescription:
        "This chatbot was built surprisingly fast with Botpress",
      botId: "<YOUR_BOT_ID>",
      hostUrl: "<YOUR_BOT_HOST_URL>",
      messagingUrl: "https://messaging.botpress.cloud",
      clientId: "<YOUR_CLIENT_ID>",
    });
  };

🛠️ make sure that you type on top of the layout.tsx "use client" to make it a client component.

You have successfully integrated your bot into your next.js 13 app! 🎉

How to build a Telegram Bot with ChatGPT integration.

hayerhans — Mon, 10 Jul 2023 17:37:15 +0000

This tutorial explains step-by-step how to build a custom Telegram chatbot that can interact with OpenAI ChatGPT. The tutorial is written in Python and uses the python-telegram-bot and openai packages.

1) Create Telegram Chatbot

Open your IDE and create a file named telegram-bot.py

We are going to use this https://github.com/python-telegram-bot/python-telegram-bot package that will help us to create the telegram bot. Make sure to install it with

pip3 install python-telegram-bot python-dotenv

After installing, paste in this code to your telegram-bot.py file:



import logging
import os

from dotenv import load_dotenv
from telegram import Update
from telegram.ext import (ApplicationBuilder, CommandHandler, ContextTypes,
                          MessageHandler, filters)

load_dotenv()

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
TELEGRAM_API_TOKEN = os.getenv("TELEGRAM_API_TOKEN")

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(chat_id=update.effective_chat.id, text="I'm a bot, please talk to me!")

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(chat_id=update.effective_chat.id, text=update.message.text)

if __name__ == '__main__':
    application = ApplicationBuilder().token(TELEGRAM_API_TOKEN).build()

    start_handler = CommandHandler('start', start)
    echo_handler = MessageHandler(filters.TEXT & (~filters.COMMAND), echo)
    application.add_handler(start_handler)
    application.add_handler(echo_handler)

    application.run_polling()

We are defining two handlers, one command helper (so if you type /start in telegram) and one message handler.

The message handler (funcion echo) for testing purposes only gives back what the user typed. So let's try out our bot. But before we can do this we need to register our bot at telegram in order to get the API_KEY.

1.1) Register our bot at telegram

Head over to https://web.telegram.org/k/ and log in with your smartphone. Use the search bar to search for “BotFather”.

Start the registration with the /start command.

It lists all possible commands, we go further with /newbot to register a new bot.

Now try to find a good name for your bot, I had some struggles:

After successful registration you will get a message from BotFather that your bot is registered, where you can find it and the token to access it. Copy this token

Create a .env file in the same directory as the telegram-bot.py file, and add the following line to it:



TELEGRAM_API_TOKEN=<your_telegram_api_token>

Replace <your_telegram_api_token> with your actual Telegram API token provided by BotFather.

We can now test your telegram bot ! In your IDE open a terminal and in the path where you script is start the bot with

python3 telegram-bot.py

Open the link where you can find your bot or use the search bar on telegram to find it. Click the start button and lets write something.

Sweet! We have successfully achieved part 1. What we now need to do is to connect our bot with ChatGPT. The idea is simple, the bot is taking the users input. We will query ChatGPT with this input and redirect the answer from ChatGPT back to our user. Lets go!

2) Create the CHAT-GPT Client

Let’s create a new python file that will handle all the ChatGPT Stuff, I will call it

“chatgpt_client.py”.

We are going to use the official openai python package to query chatgpt api. lets install the openai python package with

pip3 install openai

Copy this code to the new created file:



import os
import openai

openai.api_key = os.getenv("OPENAI_API_KEY")

def request_chat_gpt(user_message):
    try:
        completion = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "user", "content": user_message}
            ]
        )
        return completion.choices[0].message['content']
    except Exception as e:
        print(f"An error occurred: {e}")
        return ""  # Return an empty string or handle the error appropriately

Now move to the openAI website and get your token.

Place the API key in the .env file, add the following line:



OPENAI_API_KEY="<your_openai_api_key>"

Replace <your_openai_api_key> with your actual OpenAI API key.

To use the openai integration in the echo handler, we can replace the line await context.bot.send_message(chat_id=update.effective_chat.id, text=update.message.text) with the following:



response = request_chat_gpt(update.message.text)
await context.bot.send_message(chat_id=update.effective_chat.id, text=response)

Of course don’t forget to import the function

from chatgpt_client import request_chat_gpt

This will send the user's input to the request_chat_gpt function, which will use the OpenAI API to generate a response. The response will then be sent back to the user via the echo handler.

Thats all! Hope you enjoyed this one. Next time we are going to build a AirBnB Chatbot that can respond to guests with custom knowledge like Wifi Passwort or Checkout Times, sounds cool right ?

If you don't want to miss this article go to my site and subscribe the Newsletter, I would really appreciate this ❤️!

https://jhayer.tech

This script translates your language json to any language easily

hayerhans — Sat, 11 Mar 2023 15:54:56 +0000

You can find the Github Repo on my original blog post here:
https://jhayer.tech/blog/easily-translate-json-files

Lets dive into it, its not much so we can go through it step by step.

async function mirrorObject(obj, targetLang) {
const mirroredObj = {};

for (const [key, value] of Object.entries(obj)) {
  if (typeof value === "object") {
    mirroredObj[key] = await mirrorObject(value, targetLang);
  } else {
    mirroredObj[key] = await translateService.translateText(
      value as string,
      targetLang
    );
  }
}

return mirroredObj;
}

This is our first function the mirrorObject. It has one simple job, to mirror the json object structure but instead of the original value we want the translated value.

This function is recursively iterating over the json object and translating each value. You see in line 6, if the value is a object we need to call our function again, otherwise we can use the translateService to translate the value.

The translateService is simply using the node package from deepL to traslate the text, but we will have later a look at it.

async function mirrorJsonFileWithTranslation(inputFilename, outputFilename, targetLang: string) {
  // Read the JSON file
  const fileData = fs.readFileSync(inputFilename)
  const jsonData = JSON.parse(fileData)

  // Create a mirrored object structure
  const mirroredData = await mirrorObject(jsonData, targetLang)

  // Write the mirrored data to a new file
  fs.writeFileSync(outputFilename, JSON.stringify(mirroredData, null, 2))

  console.log('Mirroring complete!')
}

Here we will have a look at the mirrorJsonFileWithTranslation function. This function is reading the json file (with the parameter inputFilename), calling our previously defined mirrorObject function with the desired target language and writes the result to a new json file (parameter outputFilename). What we need now is our entry function the main, to orchestrate the whole process :)


(async () => {
const fileNames = ["common.json"];
const targetLangs = ["es", "fr"] as string[];
const fileName = fileNames[0];
for (const val in targetLangs) {
  const targetLang = targetLangs[val];
  console.log(
    `./locales/en/${fileName}.json`,
    `./locales/${targetLang}/${fileName}.json`
  );
  await mirrorJsonFileWithTranslation(
    `./locales/de/${fileName}.json`,
    `./locales/${targetLang}/${fileName}.json`,
    targetLang
  );
}
})();

Here we define fileNames as an array for the json files we want to translate. In the targetLangs array we define the languages we want to translate to. We are iterating over the targetLangs array and calling the mirrorJsonFileWithTranslation function. The main function is using the async/await syntax to wait for the translation to complete before starting the next translation.

What we need now is the translateService:

import \* as deepl from "deepl-node";
import { TargetLanguageCode } from "deepl-node";
const fs = require("fs");

export interface Translation {
translateText: (
text: string,
targetLang: TargetLanguageCode
) => Promise<string>;
}
export class TranslateService implements Translation {
authKey = process.env.DEEPL_API_KEY ?? "YOUR_DEEPL_API_KEY"; // Replace with your key
translator: deepl.Translator;

constructor() {
this.translator = new deepl.Translator(this.authKey);
}

translateText = async (text: string, targetLang: string): Promise<string> => {
if (targetLang === "en") {
targetLang = "en-US";
}
const results = await this.translator.translateText(
text,
null,
targetLang as TargetLanguageCode
);
return results.text;
};
}

const translateService = new TranslateService();

export { translateService };

The translateService is using the deepl-node package to translate the text. We are using the environment variable DEEPL_API_KEY to store our deepl api key. If you don't have one you can get one for free here: https://www.deepl.com/pro#developer

To run the script just run: npx ts-node translator.ts

Now you can easily create multiple translations for your web application, maybe you can even automate the process with a github action or build an API to translate your web application on the fly ?