DEV Community: Kiu

Create your own n8n custom node

Kiu — Mon, 02 Jun 2025 16:32:38 +0000

In some cases, the existing n8n nodes are not enough. You may want to add support for a new service or simplify an existing node for your own needs. This tutorial shows you how to build a custom n8n node from scratch. As an example, we will create a node that uses the Binance API to get the current price of a cryptocurrency.

We begin by setting up a local development environment. We use Git and Docker Desktop on a Windows PC. Starting with a fresh system, we clone the n8n self-hosted AI Starter Kit from GitHub. After adjusting the configuration for our setup (such as using the CPU profile), Docker downloads the needed images and sets up the container environment.

Once the n8n instance is running, we open it in the browser and create the admin account. Before we can deploy custom nodes, we must create a folder called custom inside the Docker container. We do this by accessing the container shell and creating the folder at /home/node/.n8n/custom.

Next, we prepare our custom node. We clone the n8n-nodes-starter repository and rename it to follow the community naming convention (e.g., n8n-nodes-b24-custom-nodes). We edit the package.json, update the project name, and configure additional metadata. We also install required tools like pnpm and rimraf, and set up a script to build and deploy the node into the Docker container.

We then create our actual node by copying the example node and renaming it. We call our new node B24CryptoManager. It will fetch the price of a coin using Binance's public API, which does not require authentication. We clean up the code, remove the unused execute method, and add a single parameter: the symbol of the coin, like BTCUSDT.

After building the project, we deploy it using our custom script. Once deployed, we open n8n again and create a test workflow. Our custom node appears in the node search. We add it, enter a coin symbol, and execute the node. The current price is returned as JSON—just like with any standard n8n node.

To make the node dynamic, we add a Set node that passes a symbol value like ETHUSDT. We configure our custom node to use that input value instead of the default. After running the workflow again, it returns the Ethereum price correctly. This confirms that everything works as expected.

With that, we’ve successfully built and deployed our first custom n8n node. In the next part, we will explore how to add authentication to custom nodes for services that require API keys or tokens.

If you are interested in AI, Automation or finance you can join:
https://www.skool.com/business24ai

Create your own MCP Server

Kiu — Mon, 24 Mar 2025 18:45:25 +0000

Setting up your own MCP server allows seamless integration with Cursor, Windsurf, and Claude Desktop using a single configuration.

After creating the MCP server with FastMCP, verifying it with MCP Inspector, and adding tools, the same configuration can be used across all three IDEs.

Simply copy the MCP settings like:

{
    "mcpServers": {
        "my-mcp-server-ratio": {
            "command": "uv",
            "args": [
                "--directory",
                "/Users/kiu/dev/my-mcp-server-ratio",
                "run",
                "main.py"
            ]
        }
    }
}

into each platform's configuration file—Cursor's mcp.json, Windsurf's mcp_config.json, and Claude Desktop's Claude_Desktop_Config.json —then restart or refresh the IDE to establish the connection.

Once set up, the MCP tools can be used effortlessly, with options for manual approval or auto-run mode for a smoother workflow.

🚀 Watch the video below for a step-by-step guide!

Github:
https://github.com/business24ai/my-mcp-server-ratio

Create an AI Agent with PydanticAI in Minutes

Kiu — Sat, 18 Jan 2025 21:41:54 +0000

Creating an AI agent might sound like a daunting task, but with modern tools like Pydantic and OpenAI, it's surprisingly straightforward. In this guide, we’ll walk through building a simple AI agent step by step.

Step 1: Set Up Your Environment
To begin, we’ll create a virtual environment and install the required library: pydantic-ai. A virtual environment ensures your project dependencies are isolated and manageable.

python -m venv venv  
source venv/bin/activate  # Use `venv\Scripts\activate` on Windows
pip install pydantic-ai

Step 2: Configure Your OpenAI API Key
Before interacting with OpenAI’s models, you’ll need an API key. Set this as an environment variable to keep it secure:

OPENAI_API_KEY="your_openai_api_key"

Step 3: Write the Script
Now, let’s create the main script for our AI agent. The agent will use a system prompt and answer user questions by leveraging OpenAI’s API.

Import Libraries
We’ll begin by importing the necessary modules:

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel

Define the Model and Agent
Next, define the model and create an agent instance:

# define the model
model = OpenAIModel("gpt-4o")

# define the agent
agent = Agent(
    model=model,
    system_prompt="Be concise, reply with one sentence.",
)

Finally, we use the run_sync method to send a query to the agent and print the response:

# run the agent
result = agent.run_sync("What does AGI mean?")

# print the result
print("\n=== Data ===")
print(result.data)

# print the Usage
print("\n=== usage ===")
print(result.usage())

# print the Messages
print("\n=== messages ===")
print(result.all_messages())

Step 4: Execute the Script
Run the script to see the agent in action:

python your_script_name.py

When executed, the agent will communicate with OpenAI’s API, process the query, and return a response. For example, if you ask, “What does AGI mean?” the agent might reply:

=== Data ===
AGI stands for Artificial General Intelligence, which refers to a machine's ability to understand, learn, and apply intelligence across any task like a human.

=== usage ===
Usage(requests=1, request_tokens=25, response_tokens=31, total_tokens=56, details={'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0, 'cached_tokens': 0})

=== messages ===
[ModelRequest(parts=[SystemPromptPart(content='Be concise, reply with one sentence.', dynamic_ref=None, part_kind='system-prompt'), UserPromptPart(content='What does AGI mean?', timestamp=datetime.datetime(2025, 1, 18, 19, 17, 51, 503464, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'), ModelResponse(parts=[TextPart(content="AGI stands for Artificial General Intelligence, which refers to a machine's ability to understand, learn, and apply intelligence across any task like a human.", part_kind='text')], timestamp=datetime.datetime(2025, 1, 18, 19, 17, 52, tzinfo=datetime.timezone.utc), kind='response')]

Conclusion
In just a few lines of code, we built a functional AI agent using Pydantic and OpenAI. This setup provides a robust foundation for building more complex AI-driven applications. Whether you’re answering questions, summarizing text, or performing advanced data analysis, this simple architecture can adapt to a variety of use cases.

Let us know what you’ll create with your new AI agent!

Links:
AI Agents Community on Skool
YouTube
GitHub