Forem: Auden

How to Install OpenClaw: A Guide to Your Open-Source AI Assistant

Auden — Tue, 03 Mar 2026 09:56:54 +0000

OpenClaw (formerly ClawdBot / Moltbot) is an open-source personal AI agent that runs entirely on your own machine.

Unlike cloud-based AI assistants, OpenClaw is fully local. You control your data, your workflows, and how the agent behaves.

It's not just a chatbot — it's an action-oriented agent.

What Makes OpenClaw Different?

OpenClaw can:

Maintain persistent memory
Access your local file system
Call external services and APIs
Execute real tasks instead of just replying with text

You can interact with it through tools like Telegram or WhatsApp, or directly via a web UI or terminal.

This makes it suitable for developers who want a real AI assistant, not just a demo.

System Requirements

Before getting started, make sure you have:

Node.js ≥ 22
macOS, Linux, or Windows (via WSL2)
npm (comes with Node.js)

Check your Node version:

node -v

Quick Installation (Recommended)

The easiest way to install OpenClaw is the official one-line installer.

On macOS or Linux:

curl -fsSL https://openclaw.sh/install | bash

On Windows (PowerShell):

irm https://openclaw.sh/install.ps1 | iex

After installation, OpenClaw automatically launches an interactive onboarding wizard.

You can rerun it anytime with:

openclaw onboard --install-daemon

Initial Configuration

During onboarding, you'll configure:

AI Model Provide an API key for a supported LLM (OpenAI, Claude, Gemini, etc.). In this guide, I use the Google Gemini CLI service.

Communication Channels Choose how you want to talk to the agent (Telegram, WhatsApp, or skip for now).

Skills & Hooks Recommended: enable them. They unlock most of OpenClaw's power.

Once finished, a local web UI will start automatically.

Gateway: The Core Service

At the heart of OpenClaw is the Gateway.

The Gateway runs in the background and:

Manages LLM connections
Handles chat sessions
Dispatches commands and actions

Every message flows through the Gateway.

If it's running, your assistant is"alive".

Check system health:

openclaw doctor

Check runtime status:

openclaw status

Gateway Management Commands:

openclaw gateway install
openclaw gateway start
openclaw gateway stop
openclaw gateway restart
openclaw gateway uninstall
openclaw gateway status

Using the Web Dashboard

To open the dashboard in your browser:

openclaw dashboard

This command opens the dashboard at a local address similar to:

http://127.0.0.1:18789/?token=<temporary-token>

From there, you can:

Chat with the agent
Manage skills
Schedule tasks
View logs
Edit configurations

This is the most intuitive way to control OpenClaw.

Terminal UI (TUI)

If you prefer the terminal:

openclaw tui

You'll get a full-screen text interface with slash commands like:

/status
/model
/session
/help

Clean, focused, and developer-friendly.

Useful CLI Commands

Some commands you'll use often:

openclaw models status
openclaw channels list
openclaw memory search
openclaw docs

They cover model health, integrations, memory search, and documentation lookup.

Final Thoughts

OpenClaw is more than a local chatbot.

It's a foundation for building your own AI agent — one that can grow, learn, and act on your behalf.

If you care about privacy, control, and extensibility, it's absolutely worth exploring.

Bonus: A Must-Have Tool for API Development – Apidog

Alongside OpenClaw, there's another powerful productivity tool for developers: Apidog.

Apidog is an all-in-one platform for API documentation, API debugging, API design, API testing, mocking, and automation. It streamlines your entire API workflow — making it one of the best tools to boost development efficiency.

If you're actively building and testing APIs, give Apidog a try. Signing up is easy — just register here.

After registering, explore the official demo projects. They're carefully crafted to help you get up to speed with Apidog's core features.

A major benefit of Apidog is its full compatibility with Postman and Swagger formats. If you've used those tools before, importing your existing data will be effortless. The intuitive interface also makes it beginner-friendly — even first-time users can get started quickly.

Postman Limits Free Plan to 1 User: Here's the Best Alternative

Auden — Tue, 03 Mar 2026 07:02:56 +0000

After March 1, many developers suddenly realized they were standing at the paywall.

On March 3, 2026, I opened Postman like I always do, just to test an API.

Instead, I was greeted by a popup:

Your Free plan has been updated

Your workspace has been moved to the new Free plan, designed for individual use (1 user).

At first glance, the message feels reassuring.

No action required.

Still free.

Mocks, specs, even performance testing are included.

Nothing looks alarming — until you slow down and read this line carefully:

designed for individual use (1 user)

And that's the moment it clicks.

Yes — starting March 1, 2026, Postman officially closed the door on free team workspaces.

Postman didn't remove "free" — it redefined it

Let's be clear about one thing first.

Postman didn't suddenly become paid-only.

What it did instead was redefine what "free" actually means.

Free now means: one person.

The moment collaboration enters the picture, you're no longer in the free world.

If you're just testing APIs on your own, everything still works fine.

But as soon as you want to share a workspace, maintain API docs together, or run mocks and tests as a team, you've crossed into a paid scenario.

That shift is subtle, but fundamental.

Why did this change trigger such a strong reaction?

Because in the real world, API tools are almost never used by just one person.

The real value of Postman was never about sending requests.

It was about shared API understanding: documentation, mock servers, team debugging, and keeping frontend and backend aligned.

Now, that entire collaboration layer has been clearly placed behind a paywall.

So this isn't really a price increase.

It's something more structural:

The most common usage pattern has become a paid feature.

That's exactly when I started taking Apidog seriously

Once you realize that Postman's free plan has effectively become a single-user tool, a question naturally comes up:

Is there an API tool that treats collaboration as a default, not an upgrade?

The answer is yes — and more developers are talking about it lately.

That tool is Apidog.

Why is Apidog suddenly mentioned everywhere?

In one sentence:

Apidog turns what Postman charges for — collaboration — into a free, default capability.

Using Apidog feels different in a very practical way.

You don't start by counting seats.

You don't hesitate before inviting teammates.

You don't worry that a future popup will tell you collaboration now requires an upgrade.

The free plan supports up to four people, which is more than enough for many small teams — but that number isn't really the point.

The point is that collaboration isn't treated as a restricted privilege, it's treated as the baseline.

Two products, two very different philosophies

Postman's direction is clear:

Free for individuals, paid for collaboration, higher tiers for automation and AI.

Apidog's direction is also clear:

Support real team workflows first, and reserve paid plans for more complex or enterprise-level needs.

Neither approach is inherently wrong.

But they lead to very different experiences depending on where you are as a developer or a team.

And that difference isn't about features — it's about mental overhead.

Final thoughts

If you're a solo developer, Postman is still a mature and reliable tool.

That hasn't changed.

But if you're working on a team project, maintaining APIs together, and don't want your workflow interrupted by seat limits and pricing prompts, then this moment is worth paying attention to.

That's why so many developers are starting to seriously look at Apidog — not just "trying it out," but actually switching.

Not because it shouts louder, but because when one door quietly closed, another one stayed open.

If you want to read a detailed, real-world migration story, this article is worth checking out:

https://dev.to/auden/postman-ends-free-team-plans-in-march-2026-here-is-the-free-alternative-i-switched-to-118p

Tools change. Strategies change.

But team collaboration shouldn't turn into an extra line item.

AI Won't Replace APIs—It Will Only Make Them More Important

Auden — Sat, 28 Feb 2026 08:13:09 +0000

While everyone is busy discussing what AI might replace, few have noticed that AI is making one specific technology more critical than ever before: APIs.

A Counterintuitive Fact

The users calling your APIs are no longer just programmers sitting in front of their computers; they are increasingly AI Agents working 24/7 without rest.

OpenAI's GPT, Anthropic's Claude, Google's Gemini, as well as Meta's Llama, Mistral, and Grok--they are all incredibly intelligent. They can write code, analyze data, and engage in human-like dialogue.

But if you think about it carefully, they share one common and fatal limitation: They know everything, but they can't do anything.

An AI model cannot help you place an order, transfer funds, or modify a single record in a database. It is merely a brain. For a brain to control the world, it needs hands and feet.

APIs are the hands and feet of AI.

Why the Stronger the AI, the More Important the API?

### AI Doesn't Create Value; APIs Do

This statement might seem absurd, but it is the truth.

When you ask ChatGPT to "book a flight to London for tomorrow," is it the Large Language Model (LLM) itself that completes the booking? Certainly not. The actual execution chain consists of the airline's API, payment APIs, user authentication APIs, and other Tools called behind the scenes. The LLM merely understands your intent and translates it into a series of API calls.

In other words: AI is the translator; the API is the executor.

Without APIs, AI is like a brilliant strategist who only knows how to fight on paper--full of profound analysis, but unable to get a single thing done.

This explains why OpenAI launched Function Calling, Anthropic introduced the Model Context Protocol (MCP) and Skills, and Google rolled out Vertex AI Extensions. Despite the fancy names, they are all essentially doing the same thing: standardizing the way AI invokes APIs.

The smartest people in the entire AI industry are working desperately to solve a core problem that isn't "making AI smarter," but rather "making AI call APIs better."

### Every AI Agent is a Super-Consumer of APIs

How many times a day can a human developer call an API? Dozens? Hundreds?

What about an AI Agent? It can invoke dozens of APIs in a single second, 365 days a year. The API consumption of a single Agent could easily match that of an entire development team.

And this is just the beginning.

When AI Agents begin to collaborate--Agent A calls Agent B, Agent B calls Agent C, and each Agent calls a bunch of external APIs--it creates a chain reaction of API calls. Behind a single user request, there might be dozens or even hundreds of API calls.

When billions of Agents are running simultaneously around the world, each calling APIs every minute, what does that mean?

It means API traffic is about to see the most violent explosion in the history of the internet.

### API Quality Defines the Ceiling of AI Capability

This is the most critical point, and also the most overlooked.

We often see benchmarks like: "GPT-5 is 30% stronger than GPT-4" or "Claude exceeds Gemini in reasoning capabilities." But rarely does anyone ask: If the quality of the APIs being called by the AI is poor, what use is even the strongest model?

For example: You ask an AI Agent to check inventory, and it calls an inventory API. But this API:

Returns an error message {"error": "fail"} without an error code or a reason.
Has a field named qty without a description explaining whether this is "available stock" or "total inventory."
Lacks idempotency design; the Agent retries once, and the inventory is deducted twice.

In this scenario, even if you are using the world's most powerful AI model, the result will be catastrophic.

The ceiling of an AI's capability does not depend on the number of model parameters; it depends on the quality of the APIs it can call.

It's like being given a genius brain but having limbs that are dysfunctional--you simply cannot achieve what you intend to do.

The Paradigm of API Management is Changing

For the past 20 years, the core mission of API management has been: How to make it more efficient for human developers to design, debug, test, and use APIs.

Swagger solved the problem of documentation standardization. Postman solved the problem of debugging efficiency. Apidog attempted to bridge the gap between fragmented toolchains by integrating documentation, debugging, mocking, and testing into a single toolset.

These tools have done a great job. But they all share a common implicit assumption: The consumer of the API is a human developer.

That assumption is now being shattered.

From "Human-Reading Docs" to "AI-Parsing Schemas"

Human developers read API documentation based on intuition and experience. When you see a field named userId, you don't need an explanation to know it's a user ID. When you see a 404 return code, you naturally understand the resource doesn't exist.

AI Agents have no such intuition.

They rely on the precision of the Schema and the completeness of the descriptions. If an OpenAPI definition lacks a description for a field, it might not matter to a human, but for an AI, it's a "black hole"--it doesn't know what the field is, so it can only guess, and the probability of guessing wrong is extremely high.

This means: API documentation standards need an upgrade--from "human-readable" to "AI-consumable with precision."

From "Manual Testing" to "Agent Behavior Simulation"

Traditional API testing focuses on functional correctness: Input A, return B, test passed.

But an Agent's calling pattern is completely different:

Retries: If the network times out, the Agent will retry automatically. If your interface is not idempotent, your data could be corrupted.
Concurrency: Multiple Agents might call the same interface simultaneously. Can your interface handle the load?
Orchestration: Agents will string multiple APIs together to complete a complex task. If a step in the middle fails, is there a rollback mechanism?
Exploration: Agents might try calling combinations of fields not explicitly written in the docs. Will your interface reject them gracefully or just crash?

Traditional testing tools hardly cover these scenarios. API testing needs to add a new dimension: Agent Behavior Simulation.

From "API Markets" to "AI Tool Stores"

Current API marketplaces (like RapidAPI or the Apidog API Hub) are for human developers to browse--you search, read the docs, and integrate manually.

The API marketplace of the future is for AI Agents. An Agent needs to complete a task, so it automatically searches for available APIs, automatically understands the Schema, and automatically completes the call. No human intervention is required.

This isn't science fiction. The MCP protocol is already doing this--it defines how AI discovers and invokes external tools (which are, in essence, APIs).

Whoever turns their API ecosystem into an AI-friendly "Tool Store" first will secure the traffic entry point of the AI era. (Just as the recent explosion of GPTs integration into platforms like Slack or Zapier has demonstrated, this is the value brought by open API platforms.)

The Evolution of Traditional Tools

This brings us to a natural question: Are existing API management tools ready?

The answer is: Most are not.

But change has begun. Taking Apidog as an example, its product architecture--visual Schema design, smart Mocking, automated testing, and API Hub--naturally possesses the foundation to evolve for the AI era:

Visual Schema Design -> Naturally transitions to "AI-readable precise definitions."
Smart Mocking -> Evolves into an "AI Agent Development Environment," where Agents can debug without waiting for the backend.
Automated Testing -> Adds "Agent Behavior Pattern Testing," covering retries, concurrency, and orchestrated calls.
API Hub -> Evolves into an "AI Tool Discovery Platform," where Agents automatically search and integrate APIs.

This isn't just an opportunity for a single tool; it's an upgrade window for the entire API management category.

The Undervalued Infrastructure

Returning to the title of this article: AI won't replace APIs; it will only make them more important.

This isn't a phrase of consolation. It is a sober observation of the technical architecture in the AI era.

While everyone is chasing larger models, stronger reasoning capabilities, and cooler Agent frameworks, a simple fact is being ignored:

The ceiling of AI is determined by computing power, by data, and even more so by the breadth and quality of the APIs it can call.

No matter how smart an AI Agent is, without high-quality APIs available, it is just a genius trapped in a glass box--able to see the world outside, but unable to touch it.

So, if you are a designer, developer, or manager of APIs, congratulations--the work you are doing will not only remain valuable in the AI era, but it will become the most critical infrastructure.

APIs are the bridge between AI and the real world. The more bridges there are, and the sturdier they are, the further AI can go.

And the tools that help you build those bridges--whether it's Apidog, Postman, or anything else--their mission is also quietly upgrading: from helping humans manage APIs to helping this world pave the way for AI.

This, perhaps, is the greatest space for imagination in the field of API management.

How to Use the Claude Opus 4.6 API: A Step-by-Step Tutorial

Auden — Fri, 06 Feb 2026 07:39:57 +0000

Recently, Anthropic launched its most powerful model to date — Claude Opus 4.6. It sets new benchmarks in coding, AI Agents, and enterprise workflows, boasting a massive 1M context window and powerful hybrid reasoning capabilities. For developers, this means the ability to build smarter, more reliable AI applications.

To unleash the full potential of Claude Opus 4.6, the first step is to learn how to call its API. Writing code directly for debugging can be both time-consuming and tedious, especially for developers who are new to APIs. A more efficient way is to use a professional API tool that allows you to intuitively build and test API requests in a graphical interface. Apidog is such a powerful tool that integrates API design, debugging, and testing, making it perfect for exploring and debugging the Claude API.

This article will detail how to use Apidog to call the Claude Opus 4.6 API step-by-step from scratch, allowing you to interact intuitively with this top-tier AI model without writing any code.

Preparation: Get Your API Key

Before communicating with any API, you need a credential to prove you have access rights, typically called an API Key. It is a unique string that needs to be attached to every request so the server can verify your identity.

To get a Claude API Key, you need to visit Anthropic's official Claude Developer Platform. After logging into your account, you can usually find the option to create a new key in your account settings or on a dedicated "API Keys" page.

Once generated, the system will provide a string starting with sk-. This is your API Key, please keep it secure. It acts as the password for accessing Claude services, and anyone with this Key can use your account quota. We will use this Key in subsequent steps.

Understanding Claude Messages Endpoint

Claude provides an API called the Messages Endpoint, specifically designed to handle conversations with the model. When calling this API, we need to clarify several core elements:

Endpoint URL: This is the "mailing address" of the API. For the Claude Messages API, the address is https://api.anthropic.com/v1/messages.
HTTP Method: This is the "sending method". To send instructions to Claude and get a response, we need to use the POST method because it involves submitting data (our question) to the server.
Headers: These are the "envelope headers" containing important metadata, such as our identity credential (API Key) and content format specifications.
Request Body: This is the "letter content" containing the specific task we want the model to perform, such as the question to ask or the specified model.

For the Claude API, several key Headers are crucial, as shown in the table below:

Header	Example Value	Description
`x-api-key`	`sk-xxxxxxxxxxxxxxxxx`	The API Key for authentication. Replace with your own Key.
`anthropic-version`	`2023-06-01`	Specifies the API version you wish to use, ensuring your request isn't broken by API updates.
`Content-Type`	`application/json`	Tells the server that the request body we are sending is in JSON format.

With these basic concepts understood, we can start building our first request in Apidog.

Sending Your First Request with Apidog

Apidog provides a clean graphical interface that allows us to configure API requests just like filling out a form, which is very intuitive.

Step 1: Create a New Project and Request

Open the Apidog client, where you can create a new project to manage your Claude API. In the project, click the "+" button on the left, select "HTTP Endpoint", and create a new HTTP request. You can name this request "Claude Chat" for easy lookup later.

Try it

Step 2: Quick Import using cURL Command

In actual work, we often see cURL commands in API documentation or examples. cURL is a powerful command-line tool for sending network requests. Apidog provides a very convenient feature: directly parsing cURL commands.

A complete cURL command to call the Claude API might look like this. Note that you need to replace YOUR_API_KEY with your actual API Key.

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: YOUR_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "Content-Type: application/json" \
     --data '{
         "model": "claude-opus-4-6",
         "max_tokens": 1024,
         "messages": [
             {"role": "user", "content": "Hello, please introduce yourself."}
         ]
     }'

In Apidog, there is no need to manually dismantle this command. Simply copy the entire cURL command above and paste it directly into Apidog's url bar.

Apidog will intelligently identify it as a cURL command and automatically fill in the request method, URL, Headers, and Body for you. This feature greatly improves debugging efficiency, especially when dealing with APIs containing many parameters and complex request bodies.

Step 3: Manually Construct the Request (Optional)

If you don't want to use cURL for quick import, you can also manually construct a request.

First, configure the request method and URL. According to Anthropic's API specifications, creating a conversation typically uses the POST method. Its official API base URL is https://api.anthropic.com, and the specific conversation endpoint path is /v1/messages.

So, in Apidog's url bar, select the POST method and enter the complete URL: https://api.anthropic.com/v1/messages.

Next, configure the request headers (Headers). The API server uses headers to obtain metadata, such as authentication info and content format. Calling the Claude API requires the following Headers:

x-api-key: Used to store your API Key.
anthropic-version: Specifies the API version number; this is a required field. According to official docs, you can enter a date here, e.g., 2023-06-01.
Content-Type: Declares the data format of the request body. Since we are sending JSON data, the value should be application/json.

In Apidog's "Headers" tab, add these three items one by one.

After configuring headers, the most important part is building the request body (Body). The body carries the specific task we want Claude to perform. Switch to the "Body" tab, select JSON format, and enter the following content:

{
  "model": "claude-opus-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Hello, please introduce yourself."
    }
  ]
}

This JSON data contains three key fields:

model: Specifies the model name to call; here we use claude-opus-4-6.
max_tokens: Sets the maximum length of content generated by the model (in Tokens).
messages: An array containing conversation history. Each object represents a message, where role indicates the role (user for the user) and content is the specific message content.

Step 4: Send Request and View Response

After completing any of the above steps, save the interface and go to the "Request" debugging page. If the API Key hasn't been replaced, you need to replace YOUR_API_KEY in the Headers with your actual API Key.

Then, click the "Send" button on the Apidog interface. If everything is normal, you will see the result returned by Claude Opus 4.6 in the "Response" area below after a short wait.

Apidog will send our constructed request to Anthropic's servers. Moments later, we can see the result returned by Claude in the "Response" area. A successful response is usually also in JSON format, containing the answer generated by the model.

{
  "model": "claude-opus-4-6",
  "id": "msg_01...",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello! I am Claude ..........."
    }
  ],
  ...
}

As you can see, the text field within the returned content array contains the answer from Claude Opus 4.6. This marks the successful completion of our first API call.

Exploring More Rich API Parameters

After mastering the basic calling method, we can further explore other parameters provided by the Messages API to achieve more complex interactions and finer control.

Streaming

By default, the API returns the complete response at once after the model finishes generating all content. For longer answers, users might have to wait a while. Streaming solves this problem by allowing the server to return content character by character or word by word, creating a typewriter-like real-time effect.

To enable streaming, simply add a field "stream": true to the JSON request body.

{
  "model": "claude-opus-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Hello, please introduce yourself."
    }
  ],
  "stream": true
}

When this request is sent, Apidog's response area will continuously receive the data stream in the form of Server-Sent Events (SSE), displaying the content generated by the model in real-time, which is very useful for building interactive chat applications.

Controlling Creativity and Randomness

temperature is a very interesting parameter that controls the randomness of the model's output. Its value typically ranges between 0.0 and 1.0.

A lower temperature (e.g., 0.2) makes the model's answers more deterministic and consistent, suitable for scenarios requiring precise, objective answers like factual Q&A or code generation.
A higher temperature (e.g., 0.8) makes the model's answers more creative and diverse, suitable for scenarios like brainstorming and creative writing.

Add the temperature field in the JSON to adjust it:

{
  "model": "claude-opus-4-6",
  "max_tokens": 1024,
  "temperature": 0.7,
  "messages": [
    {
      "role": "user",
      "content": "Give me an idea for a sci-fi novel."
    }
  ]
}

Multi-turn Conversation

Real conversation is not a one-off Q&A but a continuous exchange with context. The design of the Messages API naturally supports multi-turn conversations. The implementation is very simple: just include the entire previous conversation history in the messages array.

For example, after asking the first question and getting an answer, we can build a second request that includes the Q&A from the first round:

{
  "model": "claude-opus-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "What is the capital of France?"
    },
    {
      "role": "assistant",
      "content": "The capital of France is Paris."
    },
    {
      "role": "user",
      "content": "What are the famous attractions there?"
    }
  ]
}

In this request, we included the user's first question, the model's first answer, and the user's second question. This way, when answering "What are the famous attractions there?", the model can understand that "there" refers to "Paris" and provide relevant answers.

To facilitate review, the following table summarizes the functions of several common API parameters:

Parameter	Type	Description
`model`	string	Specifies the model to use, e.g., `claude-opus-4-6`.
`messages`	array	Conversation history, containing alternating messages from user and assistant.
`max_tokens`	integer	Limit on the maximum length of generated content.
`temperature`	float	Controls output randomness; higher values are more creative.
`stream`	boolean	Whether to enable streaming; `true` means enabled.

Using Apidog to Boost Debugging Efficiency

Apidog is not just a request sending tool; it also provides many advanced features that can significantly improve the efficiency of API debugging and development.

Manage API Keys with Environment Variables

Hardcoding API Keys directly in request headers poses security risks and makes it inconvenient to switch between different environments (like development and production). Apidog's environment variable feature can solve this problem perfectly.

We can create a variable named claude_api_key in Apidog's environment management and set its value to your API Key.

Then, in the Headers settings of the request, modify the value of x-api-key to {{claude_api_key}}.

This way, Apidog will automatically replace it with the real value when sending the request. When you need to change the Key, just modify the environment variable, and all endpoints using this variable will automatically update—safe and efficient.

Save and Reuse Endpoints

Endpoint debugging in Apidog can be saved. This means your constructed Claude API requests, including URL, Headers, Body, and various parameter configurations, can be reused with one click. This is not only convenient for your own repeated testing but also facilitates sharing with team members to ensure everyone uses a unified API definition for collaborative development.

Auto-generate Code

One of the most exciting features after successfully debugging an API in Apidog is "Code Generation". You can find a "Generate Code" option on the right side of the endpoint documentation.

After clicking, Apidog can automatically generate code in multiple programming languages and frameworks based on your current request configuration, such as Python (requests library), JavaScript (axios or fetch), Java, Go, Curl, etc.

This means seamless integration from API debugging to the project. You don't need to manually write tedious HTTP request code; just copy the code snippet generated by Apidog into your project to quickly implement the call to the Claude API, allowing you to focus entirely on developing business logic.

Through the above steps, we have not only learned how to use Apidog to call and debug the Claude Opus 4.6 API but also mastered methods to use advanced features to improve development efficiency. From sending the first "Hello" to implementing multi-turn conversations with context, and then to one-click project code generation, the entire process is completed in an intuitive, unified platform. This paves the way for you to further explore Claude's powerful capabilities and build innovative AI applications.

Postman Ends Free Team Plans in March 2026. Here Is The Free Alternative I Switched To

Auden — Thu, 05 Feb 2026 06:18:04 +0000

Recently, news from Postman has caused quite a stir in the developer community. According to their official blog and emails sent to users, Postman's pricing and product plans are undergoing a major overhaul effective March 1, 2026.

The most critical change is to the Free plan, which currently supports team collaboration. It will be adjusted to single-user only. This means that if your team relies on the free version of Postman for collaborative API development and testing, you will soon be forced to upgrade to a paid Team plan.

For many small teams with limited budgets, open-source contributors, and learners, this is an issue that cannot be ignored. When a familiar tool no longer offers free collaboration, finding a suitable alternative becomes urgent.

What Do the Changes to Postman Mean?

Before discussing alternatives, it's necessary to clearly understand the specific impact of Postman's adjustments. This change isn't just a simple feature reduction; it's a strategic shift in product positioning that directly affects how free users operate.

Core Restrictions of the Free Plan

According to Postman, starting March 1, 2026, the new Free plan will be strictly limited to a single user.

This means the workflow of inviting multiple members to a Workspace, sharing API Collections, and synchronizing development progress—features we've taken for granted—will no longer exist in the free version. Any scenario requiring collaboration between two or more people will require migration to a paid plan.

For users accustomed to collaborating within Postman, this presents a direct challenge. Either the entire team pays for collaboration features, or you regress to a primitive state where everyone manages APIs locally on their own machines—a move that undoubtedly kills development efficiency and consistency.

Why You Need an Alternative

Postman's new plans introduce many powerful features, such as native AI capabilities, deeper integration with Git workflows, and a brand-new API Catalog. These are indeed attractive for large enterprises or teams pursuing extreme efficiency.

However, for many developers and smaller teams, the most basic and core requirement is simply stable and free team collaboration. When this fundamental need becomes a paid feature, cost becomes an unavoidable factor.

Therefore, finding a tool that satisfies core functions like API design, debugging, and testing, while also providing complete team collaboration capabilities on a free tier, is the most practical choice.

Enter Apidog, an all-in-one API collaboration platform that combines API design, development, and testing. With its robust free team collaboration capabilities, it has become a top contender for developers looking to migrate.

Try it

Why Choose Apidog?

Among the myriad of API tools available, Apidog has a very clear positioning: an all-in-one API platform built for team collaboration. It is not just an API request tool; it spans the entire API lifecycle from design and documentation to development, testing, and release.

Most importantly, Apidog's core team collaboration features are generous for free users, making it the ideal choice to counter Postman's policy changes.

Here is a simple comparison to visualize Apidog's advantages in team collaboration:

Feature	Postman (Free Plan after March 2026)	Apidog (Free Plan)
Team Size	Limited to 1 User	Up to 4 Users
Collaboration	Not supported (Upgrade required)	Real-time data sync, interface comments, permission management
API Design & Docs	Manual writing supported	Visual design support with auto-generated, shareable documentation
Mock Server	Supported, with limits	Powerful advanced Mock features with custom rules
Auto Testing	Supported, with limits	Support for test case orchestration, assertions, and test reports
Core Positioning	Individual Developer Tool	Team Collaborative API Platform

As shown in the table, while Postman's free version retreats to being a personal tool, Apidog continues to champion team collaboration as a core value. It doesn't just solve the problem of "can we collaborate?"; it offers richer functionality in the depth and breadth of that collaboration.

Migrating from Postman to Apidog

Moving from a familiar tool to a new one often brings anxiety about data loss and learning curves. Fortunately, Apidog provides a seamless Postman data import feature, making the entire migration process smooth and painless.

The process consists of two main steps: exporting data from Postman and importing it into Apidog.

1. Exporting Postman Data

In Postman, your core assets are usually Collections and Environments.

A Collection is a set of all your saved API requests, including URLs, methods, headers, bodies, etc. An Environment stores variables for different contexts, such as API_HOST for development versus production.

First, you need to export this data to files.

Open the Postman client and find the Collection you want to export in the left navigation bar.

Click the three dots (...) icon next to the Collection and select Export.
In the popup window, choose the recommended Collection v2.1 format and save the JSON file to your local machine.

Next, export your environments in the same way. Click the Environments tab on the left, find the environment you need, click the three dots (...), select Export, and save it as a JSON file.

2. Importing Data into Apidog

Once you have your JSON files, you can import them into Apidog.

Open Apidog and enter your project.
Click "Settings" (usually a gear icon) in the left sidebar.
Select "Import Data" and choose the "Postman" option.

Apidog will present an upload interface. You can drag and drop your exported Collection and Environment JSON files directly into the upload area. Apidog supports uploading multiple files at once and will automatically recognize and process them.

After uploading, Apidog parses the file content, seamlessly converting Postman requests, directory structures, and environment variables into Apidog's interfaces and environments. Once the import is successful, you'll see all your familiar API requests ready to go in the Apidog interface.

Start Collaborating in Apidog

With data migration complete, you can now truly experience the collaborative benefits of Apidog.

Invite Team Members

The first step in collaboration is building your team. In Apidog, inviting colleagues is straightforward.

Click on "Settings" or "Members/Permissions" in your project or team dashboard.
Invite new members via a shareable link or email invitation.

Unlike Postman's upcoming single-user limit, Apidog allows you to add up to 4 team members for free. It also offers a flexible permission management system, allowing you to assign different roles (Admin, Editor, Read-only, etc.) to ensure project data security.

Experience the All-in-One Workflow

Apidog's strength lies in its "All-in-One" design philosophy. It's not just a Postman replacement; it's a platform that covers the full API lifecycle.

Design First: Collaboration often starts with API design. You can define paths, parameters, request bodies, and response structures visually directly on the platform.
Auto-Generated Docs: Once the API is designed, professional and beautiful API documentation is generated automatically. You can share this online with frontend colleagues or third-party partners, who can view and debug directly in their browser without installing software.
Smart Mocks: For frontend developers, Apidog's Mock function is a game-changer. Based on your API design, Apidog automatically generates realistic Mock data. This means frontend work doesn't need to wait for the backend interface to be finished—you can develop and integrate based on Mock data immediately, significantly boosting parallel development efficiency.
Automated Testing: When the backend interface is ready, team members can perform debugging and automated testing within Apidog. You can combine multiple requests into a test case, set assertions to verify results, and run all tests with one click to generate detailed reports.

Conclusion

Facing Postman's free tier adjustments, there's no need to panic. The tech ecosystem is constantly evolving. While Postman's choice is part of their business strategy, for the vast majority of developers and teams, this is an opportunity to discover and embrace tools like Apidog—tools designed for modern team collaboration that are more integrated, efficient, and generous with their free tiers.

How to Use the Claude Opus 4.6 API: A Step-by-Step Tutorial

Google Gemini CLI Tutorial: How to Install and Use It (With Images)

Auden — Thu, 26 Jun 2025 09:58:10 +0000

What is Gemini CLI?

Gemini CLI is an open-source command-line AI tool developed by the Google Gemini team, specifically designed for developers. It can understand code, execute complex queries, automate tasks, and leverage Gemini’s multimodal capabilities (like image recognition) to generate creative content.

GitHub: https://github.com/google-gemini/gemini-cli

Key Features:

Large codebase support: Handles over 1 million tokens in context, making it easy to analyze large projects.
Multimodal app prototyping: Quickly generate app prototypes from PDFs or sketches.
Automated DevOps tasks: Perform Git operations, fetch PRs, create migration plans, and more.
Tool integration: Connect to media generation models like Imagen, Veo, and Lyria via an MCP server.
Web search ready: Built-in Google Search ensures up-to-date, reliable responses.

How to Install Gemini CLI

Prerequisites

Make sure you have Node.js 18 or later installed. You can check by running:

node -v

This guide uses macOS as an example, but the steps are similar on Windows — everything happens in the terminal.

Option 1: Run Directly (No Installation)

npx https://github.com/google-gemini/gemini-cli

Option 2: Global Installation (Recommended)

Run the following command in your terminal (you may be prompted to enter your system password if using sudo):

sudo npm install -g @google/gemini-cli

Once installed, just type gemini in your terminal to launch the interactive CLI. On the first run, it may request some permissions — simply confirm to proceed.

First-Time Setup

Upon launch, the CLI will guide you through the following steps:

Step 1: Choose a Theme

Select a preferred theme style from the options provided. Hit Enter to confirm.

Step 2: Sign-In Method

Choose a login method. We recommend "Login with Google", which allows up to 60 requests/minute and 1,000 requests/day for free. Select it and hit Enter.

If you need higher rate limits or enterprise access, you can use an API key:

Obtain your API key from Google AI Studio.
Set it as an environment variable:

export GEMINI_API_KEY="YOUR_API_KEY"

Note: Using an API key is typically for direct API calls — this guide focuses on the CLI experience. You can learn more about Gemini API in this guide: Guide: What is Google Gemini API and How to Use It?

Step 3: Browser Authentication

After selecting your sign-in method, a browser window will open. Simply log in with your Google account.

After Login

Once authenticated, you’ll see a confirmation message like this:

Getting Started

You can now enter prompts directly in the CLI. For example:

To upload and reference local files, use @ in the CLI to trigger file selection:

Using Gemini CLI in VSCode

Try running gemini directly in VSCode’s integrated terminal. After that, use the @ command to select a file and begin a conversation.

For example:

Help me write a simple calculator

The CLI might request "write access" during the process — just confirm. Here's the (slightly ugly) result:

Tips & Tricks

If your connection is unstable, Gemini CLI may automatically fall back from the gemini-2.5-pro model to the faster gemini-2.5-flash model.

To discover available commands and usage tips, type / in the CLI.

Gemini CLI is a powerful AI companion for developers, DevOps engineers, and data analysts. It simplifies code analysis, automates workflows, and supports creative generation — all via natural language instructions.

Bonus: A Must-Have Tool for API Development – Apidog

Alongside Gemini CLI, there’s another powerful productivity tool for developers: Apidog.

If you’re actively building and testing APIs, give Apidog a try. Signing up is easy — just register [here].

After registering, explore the official demo projects. They’re carefully crafted to help you get up to speed with Apidog’s core features.

A major benefit of Apidog is its full compatibility with Postman and Swagger formats. If you’ve used those tools before, importing your existing data will be effortless. The intuitive interface also makes it beginner-friendly — even first-time users can get started quickly.

What is FastAPI MCP? Effortless AI Integration for Your FastAPI APIs

Auden — Thu, 24 Apr 2025 10:27:58 +0000

Today, let's dive into an exceptionally practical tool—FastAPI MCP. If you're building APIs with FastAPI and want your endpoints to be directly accessible to AI models (like GPT, Claude, etc.), this guide is for you.

📚 Table of Contents

What Is FastAPI MCP?
Why Use FastAPI MCP?
Step-by-Step: Getting Started with FastAPI MCP Locally
- Step 1: Prepare Your Python Environment
- Step 2: Install Required Packages
- Step 3: Create a Simple FastAPI Application
- Step 4: Run and Test Your Application
- Step 5: Explore the MCP Endpoint
Connecting FastAPI MCP to an AI Client
- Method 1: SSE (Server-Sent Events) Connection
- Method 2: Using mcp-remote as a Bridge
In Practice: FastAPI MCP in Action
Advanced Usage Tips
- Selectively Expose Endpoints
- Add Authentication
- Custom Response Processing
- Separate Deployment
- Security Best Practices
Conclusion
Other Recommended MCP Servers

What Is FastAPI MCP?

Put simply, FastAPI MCP is a zero-configuration solution that automatically exposes your FastAPI endpoints as Model Context Protocol (MCP) tools. With MCP compatibility, AI models can directly interact with your APIs in a seamless, standardized way.

In essence, FastAPI MCP acts as a bridge: it makes your APIs discoverable and callable by various AI models. Imagine enabling Claude or GPT—through tools like Cursor or Claude Desktop—to fetch data, process information, or trigger business logic by simply calling your API endpoints. That's not just powerful, it's fun!

Why Use FastAPI MCP?

When developing AI-powered applications, it's increasingly common to have scenarios where LLMs need to interact with external services, for example:

Querying your database
Invoking computational services
Accessing internal tools
... and much more

Traditionally, this required building custom endpoints or writing dedicated adapters for each AI integration. With FastAPI MCP, just a few lines of code can make your existing API directly available to AI models—saving significant development time and effort.

Step-by-Step: Getting Started with FastAPI MCP Locally

Step 1: Prepare Your Python Environment

First, ensure you have Python installed (version 3.10 or above is recommended). You can check your Python version by running:

python --version
# or
python3 --version

If you see a proper version number (like Python 3.10.x), your environment is ready.

Step 2: Install Required Packages

Install FastAPI, Uvicorn, and FastAPI MCP:

pip install fastapi uvicorn fastapi-mcp

Step 3: Create a Simple FastAPI Application

To ensure compatibility and minimize configuration, start with a basic example. In a new file called main.py, add the following:

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI(title="Simple API")

@app.get("/hello", operation_id="say_hello")
async def hello():
    """A simple greeting endpoint"""
    return {"message": "Hello World"}

# Expose MCP server
mcp = FastApiMCP(app, name="Simple MCP Service")
mcp.mount()

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)

This example includes a single /hello endpoint that returns a greeting.

Step 4: Run and Test Your Application

Now start your server:

python main.py

uvicorn main:app --reload

You should see your FastAPI app running at http://127.0.0.1:8000.

Step 5: Explore the MCP Endpoint

Open your browser at http://127.0.0.1:8000/mcp.

Note: Unlike standard REST APIs, the MCP endpoint utilizes Server-Sent Events (SSE), so you'll see output such as:

event: endpoint
data: /mcp/messages/?session_id=a543519a5f3848febfd4f40b5ad3b5c7

This means the MCP server is up and ready to accept connections from AI clients.

Connecting FastAPI MCP to an AI Client

Suppose you want to connect FastAPI MCP to a client like Cursor. Here’s how:

Method 1: SSE (Server-Sent Events) Connection

Most modern MCP clients (Claude Desktop, Cursor, Windsurf, etc.) support SSE. In the client settings, use a configuration like:

{
  "mcpServers": {
    "fastapi-mcp": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

For example, in Cursor, go to Settings → "MCP" → "Add new global MCP server", and add the above config in your mcp.json.

Once your FastAPI MCP server is running, the AI IDE will automatically detect it and enable new functionality.

Method 2: Using mcp-remote as a Bridge

If you need authentication support or your MCP client does not support SSE, you can use mcp-remote as a bridge:

{
  "mcpServers": {
    "fastapi-mcp": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8000/mcp",
        "8080"
      ]
    }
  }
}

In Practice: FastAPI MCP in Action

Once you’ve configured your AI client to talk to your FastAPI MCP server, you can simply ask—for example in Cursor’s Agent tab:

“Call the /hello endpoint for me”.

The AI will run the MCP tool and return the endpoint result, just as any human developer might.

Advanced Usage Tips

Once you’ve mastered the basics, FastAPI MCP offers powerful features for production scenarios:

Selectively Expose Endpoints

You likely won’t want every endpoint exposed to AI. FastAPI MCP lets you fine-tune which are accessible:

# Only expose specific operations
mcp = FastApiMCP(app, include_operations=["say_hello", "get_user_info"])

# Exclude certain operations
mcp = FastApiMCP(app, exclude_operations=["delete_user", "update_settings"])

# Expose only endpoints with specific tags
mcp = FastApiMCP(app, include_tags=["public", "read_only"])

# Exclude endpoints with specific tags
mcp = FastApiMCP(app, exclude_tags=["admin", "sensitive"])

Add Authentication

To secure your MCP endpoints, leverage FastAPI dependencies:

from fastapi import FastAPI, Depends, Security
from fastapi.security import APIKeyHeader

api_key_header = APIKeyHeader(name="X-API-Key")

async def verify_api_key(api_key: str = Security(api_key_header)):
    if api_key != "your-secret-key":
        raise HTTPException(status_code=403, detail="Invalid API key")
    return api_key

mcp = FastApiMCP(app, mcp_dependencies=[Depends(verify_api_key)])
mcp.mount()

Now, every MCP call requires a valid API key in the request headers.

Custom Response Processing

You may wish to include metadata or customize responses sent to AI:

async def response_processor(request, response, response_data):
    response_data["processed_by"] = "custom_processor"
    response_data["timestamp"] = datetime.now().isoformat()
    return response_data

mcp = FastApiMCP(app, response_processor=response_processor)
mcp.mount()

Separate Deployment

For complex setups, you may want to host your MCP server separately from your main API:

# api_app.py
from fastapi import FastAPI
api_app = FastAPI()

# mcp_app.py
from fastapi import FastAPI
from fastapi_mcp import FastApiMCP
from api_app import api_app

mcp_app = FastAPI()
mcp = FastApiMCP(api_app)
mcp.mount(mcp_app)

Deploy api_app and mcp_app independently as needed.

Security Best Practices

When using FastAPI MCP:

Only expose safe, read-only endpoints—avoid dangerous operations like DELETE and PUT.
Require authentication where appropriate.
Use Pydantic models for strict parameter validation.
Consider filtering or masking sensitive data in responses.

Conclusion

Getting started with FastAPI MCP is remarkably straightforward. With minimal effort, you can turn your API into an AI-accessible interface without rewriting existing code or spending time on custom adapters.

In summary, the core steps are:

Set up Python
Install dependencies (fastapi, uvicorn, and fastapi-mcp)
Create a FastAPI app
Add MCP support with just a few lines of code
Connect and test from your favorite AI IDE or tool

For further capabilities and the latest features, see the official FastAPI MCP documentation on GitHub.

Other Recommended MCP Servers

Apidog MCP Server allows you to provide your Apidog API documentation to AI-powered IDEs like Cursor, as well as other tools that support MCP. It covers multiple use cases: you can connect it to APIs documented within your Apidog projects, access publicly published API documentation, or even use OpenAPI/Swagger files.

Setup is extremely straightforward—just make sure you have Node.js (version 18 or newer) installed. Choose the appropriate configuration method based on your scenario. For private deployments, you can also add custom API base URLs. With Apidog MCP Server, developers can leverage AI assistants to generate code from API docs, modify code, search API documentation, and more—all dramatically enhancing development efficiency.

In practice, you simply instruct the AI assistant what you want to do with the API documentation (for example: "Generate all MVC code for the /users endpoint based on the API docs"), and the AI will understand and complete the task. This is especially valuable in collaborative team settings, ensuring all developers work from a unified, standardized API documentation source.

10 Markdown Tips for Creating Beautiful Product Documentation in 2025

Auden — Fri, 14 Mar 2025 10:39:51 +0000

In product development, excellent documentation not only clearly conveys information but also enhances team collaboration efficiency and product image. Markdown, with its concise and efficient characteristics, has become the preferred format for technical documentation. This article shares 10 practical tips to help you create professional and beautiful product documentation using Markdown.

1. Leverage Heading Hierarchy to Build Clear Document Structure

Markdown supports six levels of headings, using the # symbol to represent different heading levels. A well-structured heading hierarchy makes document organization immediately apparent:

# Level 1 Heading: Product Overview
## Level 2 Heading: Core Features
### Level 3 Heading: Feature Details

Through proper heading hierarchy, readers can quickly locate needed information, making your document well-structured and organized.

2. Use Emphasis Syntax to Highlight Important Information

Markdown's emphasis syntax can effectively improve document readability when applied to key information:

Use **text** or __text__ to bold important information
Use *text* or _text_ to italicize supplementary notes
Use ~~text~~ to indicate deprecated features

Appropriate use of these emphasis symbols can make key content visually stand out.

3. Insert Beautiful Tables to Display Data

Markdown's table functionality allows for neat presentation of data comparisons or feature lists:

| Feature | Basic | Professional | Enterprise |
| --- | :---: | :---: | :---: |
| Multi-user Collaboration | ✅ | ✅ | ✅ |
| API Testing | ❌ | ✅ | ✅ |
| Advanced Analytics | ❌ | ❌ | ✅ |

This table format is both clear and standardized, suitable for displaying various comparison information and parameter lists.

4. Use Code Blocks to Present Technical Content

For code or commands related to your product, Markdown code blocks provide syntax highlighting, improving readability:

function getProductInfo(id) {
  return api.request({
    url: `/products/${id}`,
    method: 'GET'
  });
}

Code blocks not only preserve code formatting but also enable syntax highlighting by specifying the language, making code examples easier to understand.

5. Add Blockquotes to Enhance Document Layering

Using the > symbol creates blockquotes, ideal for highlighting notes, tips, or warning information:

> 📌 **Tip**: This feature is only available in Professional and higher editions.
> 
> ⚠️ **Note**: Updating this setting will cause the system to be temporarily unavailable.

Blockquotes create visual distinction, making them perfect for emphasizing important notices or comments.

6. Flexibly Use Lists to Organize Information

Markdown supports ordered and unordered lists, which can even be nested:

1. System Settings
   * Basic Settings
   * Advanced Settings
     1. Permission Management
     2. Data Synchronization
2. User Management
   * User Roles
   * Access Control

Lists are an excellent method for organizing structured information, particularly suitable for presenting steps, feature points, or hierarchical relationships.

7. Use Horizontal Rules and Spacing to Optimize Long Documents

For longer documents, horizontal rules (---) can enhance document clarity:

---

Additionally, appropriate line breaks and paragraph indentation can make your document more readable, preventing information from being overly dense.

8. Use Links and Anchors to Improve Document Navigation

Adding internal links and anchors helps readers quickly navigate between different sections:

Table of Contents:
- [Product Introduction](#intro)
- [Core Features](#features)
- [Frequently Asked Questions](#faq)

<a id="intro"></a>
## Product Introduction

<a id="features"></a>
## Core Features

<a id="faq"></a>
## Frequently Asked Questions

This approach significantly improves navigation efficiency in long documents, allowing readers to find information without excessive scrolling.

9. Image Presentation and Layout Techniques

Inserting images in Markdown is simple, but creating beautiful documentation requires attention to image quality and layout:

![Product Dashboard Screenshot](./images/dashboard.png)

<img src="./images/dashboard.png" width="720px"/>

For images requiring explanation, add descriptive text below the image or use small headings as image captions to maintain overall document aesthetics and consistency.

10. Utilize Task Lists to Display Progress

Task lists are a particularly useful Markdown feature for clearly showing project progress or feature development status:

- [x] User Registration Module
- [x] Login Authentication System
- [ ] Data Analytics Dashboard
- [ ] Multilingual Support

This format visually represents completed and pending tasks, making it perfect for product roadmaps or feature release plans.

Beyond Native Markdown: Apidog Professional Documentation Features

The tips above are based on native Markdown syntax, sufficient for most documentation needs. However, if you're writing API documentation or need more professional technical documentation, Apidog Markdown offers powerful components that go beyond native Markdown:

Container and List Combinations for Side-by-Side Comparison

For scenarios like comparing old and new versions, Apidog's container components allow side-by-side column displays, intuitively showing differences.

<Container>

    <Columns>
      <Column>
        **Old Version**
      </Column>
      <Column>
        **New Version**
      </Column>
    </Columns>

    ---

    <Columns>
      <Column>
        This is the old version content  
        <DataSchema id="5663355" />
      </Column>


      <Column>
        This is the new version content  

        <DataSchema id="5663353" />
      </Column>
    </Columns>

</Container>

Visual Process Flows with Step Components

For operation guidance content, Apidog's step components create eye-catching visual guides, leading users through operations step by step.

<Steps>
  <Step title="Configuration Entry">
     Go to`Settings`under`Request`.
    <Background>
    ![handshake-path-configuration.png](https://api.apidog.com/api/v1/projects/544525/resources/351721/image-preview)
    </Background>
  </Step>

  <Step title="Client Version">
     The default is`v4`. If the server uses an older version (e.g., v2/v3), manually switch the client version.
  </Step>

  <Step title="Handshake Path">
     The default is`/socket.io`. If the server uses a custom path (e.g., `/custom`), update the path accordingly.
  </Step>
</Steps>

Data Schemas Reuse

One of Apidog's most powerful features is the "define once, reference everywhere" approach to data schemas. Schemas defined in the system can be directly embedded in documentation, ensuring documentation and endpoints remain synchronized, preventing inconsistencies.

FAQ Collapsible Sections

Apidog's collapsible section functionality elegantly handles frequently asked questions, hiding details while retaining key information, significantly improving document cleanliness and reading experience.

<AccordionGroup>
    <Accordion title="Block 1">
        Content of Block 1
    </Accordion>
    <Accordion title="Block 2">
        Content of Block 2
    </Accordion>
    <Accordion title="Block 3">
        Content of Block 3
    </Accordion>
</AccordionGroup>

Conclusion

Using these native Markdown techniques, we can create well-structured documents with emphasized key points. For teams requiring more professional documentation experiences, especially API development teams, Apidog Markdown's enhanced functionality brings additional value, making your documentation both beautiful and practical.

Regardless of which tool you use, remember that documentation ultimately serves users, helping them efficiently access and understand information. The combination of technical excellence and aesthetics is the winning formula for creating outstanding product documentation.

To experience these advanced feature components, visit the Apidog Markdown official documentation for more information and begin your professional documentation journey.

How to Debug the Ollama API: A Step-by-Step Guide

Auden — Wed, 12 Mar 2025 10:14:16 +0000

This article explains how to download Ollama and deploy AI large language models (such as DeepSeek-R1, Llama 3.2, etc.) locally. Using Ollama—an open-source large language model service tool—you can run powerful open-source AI models on your own computer. We'll provide comprehensive instructions for installation, setup, and most importantly, debugging the API endpoint to enable seamless interaction with your AI models.

Step 1: Download and Install Ollama
Step 2: Install AI Models
Step 3: Interact with AI Models
Step 4: Optional - Simplify Workflows with GUI/Web Tools
Step 5: Debug the Ollama API

Step 1: Download and Install Ollama

Visit Ollama's official GitHub repository: https://github.com/ollama/ollama
Download the version corresponding to your operating system (this tutorial uses macOS as an example; Windows follows similar steps).

Complete the installation.

After installation, open the Terminal (on macOS, press F4 and search for "Terminal"). Enter ollama - if the following prompt appears, installation was successful.

Step 2: Install AI Models

After installing Ollama, download the desired AI model using these commands:

ollama run llama3.2

Available models (replace llama3.2 with your preferred model):

Model	Parameters	Size	Download
DeepSeek-R1	7B	4.7GB	`ollama run deepseek-r1`
DeepSeek-R1	671B	404GB	`ollama run deepseek-r1:671b`
Llama 3.3	70B	43GB	`ollama run llama3.3`
Llama 3.2	3B	2.0GB	`ollama run llama3.2`
Llama 3.2	1B	1.3GB	`ollama run llama3.2:1b`
Llama 3.2 Vision	11B	7.9GB	`ollama run llama3.2-vision`
Llama 3.2 Vision	90B	55GB	`ollama run llama3.2-vision:90b`
Llama 3.1	8B	4.7GB	`ollama run llama3.1`
Llama 3.1	405B	231GB	`ollama run llama3.1:405b`
Phi 4	14B	9.1GB	`ollama run phi4`
Phi 4 Mini	3.8B	2.5GB	`ollama run phi4-mini`
Gemma 2	2B	1.6GB	`ollama run gemma2:2b`
Gemma 2	9B	5.5GB	`ollama run gemma2`
Gemma 2	27B	16GB	`ollama run gemma2:27b`
Mistral	7B	4.1GB	`ollama run mistral`
Moondream 2	1.4B	829MB	`ollama run moondream`
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`
LLaVA	7B	4.5GB	`ollama run llava`
Granite-3.2	8B	4.9GB	`ollama run granite3.2`

A progress indicator will appear during download (duration depends on internet speed):

When prompted with "Send a message", you're ready to interact with the model:

Step 3: Interact with Llama3.2

Example interaction (asking "Who are you?"):

Use Control + D to end the current session.
To restart later, simply rerun ollama run llama3.2.

Step 4: Optional GUI/Web Interface Support

Using a terminal for daily interactions can be inconvenient. For a more user-friendly experience, Ollama's GitHub repository lists multiple community-driven GUI and web-based tools. You can explore these options independently, as each project provides its own setup instructions. Here's a brief overview:

GUI Tools
- Ollama Desktop: Native app for macOS/Windows (supports model management and chat).
- LM Studio: Cross-platform interface with model library integration.
Web Interfaces
- Ollama WebUI: Browser-based chat interface (run locally).
- OpenWebUI: Customizable web dashboard for model interaction.

For details, visit the Ollama GitHub README.

Step 5: Debug the Ollama API

Ollama exposes a local API by default. Refer to the Ollama API Docs for details.

Below, we will use Apidog to debug the local API generated by Ollama. If you haven't installed Apidog yet, you can download and install it—it's an excellent tool for API debugging, API documentation, API mocking, and automated API testing.

Create a New Request

Copy this cURL command:

curl --location --request POST 'http://localhost:11434/api/generate' \
--header 'Content-Type: application/json' \
--data-raw '{
    "model": "llama3.2",
    "prompt": "Why is the sky blue?",
    "stream": false
}'

In Apidog:

Create a new HTTP project.
Paste the cURL into the request builder.
Save the configuration.

Send the Request

Navigate to the "Run" tab and click "Send". The AI response will appear.

For streaming output, set "stream": true.

Advanced API Debugging Tips

Here are some additional tips for debugging the Ollama API effectively:

Check API Status: Verify the Ollama service is running with:

   curl http://localhost:11434/api/version

Troubleshoot Common Issues:
- Ensure Ollama is running before making API calls
- Check that your model is correctly downloaded (ollama list)
- Verify the port isn't blocked by a firewall
Customize API Parameters: Experiment with these parameters in your requests:

   {
     "model": "llama3.2",
     "prompt": "Write a short poem about coding",
     "system": "You are a helpful assistant that writes poetry",
     "temperature": 0.7,
     "top_p": 0.9,
     "top_k": 40,
     "max_tokens": 500
   }

Implement Error Handling: Always check for error responses from the API and handle them gracefully in your applications.

Conclusion

This guide covered:

Ollama installation
Model deployment
Command-line interaction
API testing and debugging with Apidog

You now have a complete workflow for local AI model experimentation, application development, and API debugging. By mastering the Ollama API, you can build sophisticated applications that leverage powerful AI models running entirely on your local machine.

References

10 Markdown Tips for Creating Beautiful Product Documentation in 2025

5 Must-Have Socket.IO Debugging Tools for Modern Web Developers in 2025

Auden — Tue, 11 Mar 2025 10:14:32 +0000

In real-time communication application development, Socket.IO stands as a highly popular framework, offering developers convenient bidirectional communication capabilities. However, debugging Socket.IO applications can be challenging, as traditional HTTP debugging tools often fall short. Today, I'll introduce 5 excellent Socket.IO debugging tools to help you develop and test real-time communication applications more efficiently.

Apidog

Tool Name	Apidog
Free?	Yes
URL	https://apidog.com

Apidog is an all-in-one API development tool that integrates design, debugging, testing, and documentation generation. Recent versions have added comprehensive support for Socket.IO. If you're looking for a complete API development solution, Apidog is definitely the top choice.

Using Apidog to debug Socket.IO is remarkably intuitive. Simply click the "+" button on the left, select "New Socket.IO" enter the server address (supporting both ws:// and wss:// protocols), and you can quickly establish a connection. Apidog supports various versions of Socket.IO clients, using v4 by default, and for older server versions (like v2/v3), you can easily switch manually in the settings.

Apidog offers powerful Socket.IO debugging features, allowing you to listen to multiple events, send different message types (including JSON, text, and binary formats), and wait for server ACK callbacks. When sending messages, you can add multiple argument, which is particularly useful in complex Socket.IO debugging scenarios.

Even more impressive is Apidog's ability to use variables in connection arguments, enabling easy environment switching and dynamic parameter injection. After debugging, you can save Socket.IO endpoints to your project directory tree, making them accessible for team members. Apidog also supports generating endpoint documentation that can be shared with team members via URL.

For team collaboration, these Apidog features make Socket.IO endpoint development, debugging, and documentation management exceptionally convenient. Especially in large projects, being able to systematically manage Socket.IO endpoints is an important tool for improving development efficiency – give it a try!

WebSocket King

Tool Name	WebSocket King
Free?	Yes
URL	https://websocketking.com

WebSocket King is a lightweight yet powerful tool for testing WebSocket and Socket.IO. Its endpoint is clean and intuitive, making it easy to use even for developers new to WebSocket or Socket.IO.

The tool's greatest advantage lies in its usability and quick-start feature. You can simply open the website, input your Socket.IO server address, and immediately begin testing. WebSocket King supports custom event names and arguments, allowing you to easily simulate various client behaviors.

Besides basic connection and message sending functions, WebSocket King provides message history and formatted display features, making the debugging process clearer. You can view all sent and received messages, including their timestamps and content, facilitating communication flow tracking and troubleshooting.

For beginners, WebSocket King has a gentle learning curve, requiring minimal configuration to start testing, making it a good entry-level choice. While its endpoint is simple, it offers sufficient functionality for most Socket.IO debugging needs.

However, compared to professional tools like Apidog, WebSocket King is somewhat limited in team collaboration, endpoint management, and advanced features.

Socket.IO Test Client

Tool Name	Socket.IO Test Client
Free?	Yes
URL	https://chromewebstore.google.com/detail/socketio-test-client/ophmdkgfcjapomjdpfobjfbihojchbko

Socket.IO Test Client is a Chrome browser extension specifically designed for Socket.IO developers. As a browser extension, its main advantage is convenience – it's always available without needing to launch additional applications.

This plugin provides a clean endpoint for quickly connecting to Socket.IO servers, sending events, and receiving responses. It supports multiple Socket.IO versions and allows customization of event names and arguments. For routine Socket.IO development and debugging work, this tool adequately meets most needs.

Another highlight of Socket.IO Test Client is its logging capability, which records all sent and received events and provides a clear timeline view. This makes tracking communication processes and identifying issues much simpler. The plugin also supports request history features, allowing you to save previous test sessions for repeated testing.

For frontend developers, this tool's integration is a major advantage. You can test Socket.IO while developing web applications in the same browser without switching to other tools. Additionally, as a browser plugin, it better simulates real frontend environments, helping to identify issues that might occur in actual applications.

However, as a browser plugin, Socket.IO Test Client has limitations in feature richness and extensibility, such as inability to perform complex automated testing or deep integration with team collaboration tools. But for individual developers or small teams, it's a highly practical tool.

Socket.IO Inspector

Tool Name	Socket.IO Inspector
Free?	Yes
URL	https://piehost.com/socketio-tester

Socket.IO Inspector is an online Socket.IO testing tool that allows you to debug and test Socket.IO servers directly in your browser without installing any software. A key feature is its support for all versions of Socket.IO, particularly useful when dealing with older projects using different versions.

Using Socket.IO Inspector is straightforward – just visit the website, enter your Socket.IO server address (ensuring the server has CORS enabled), and begin connecting and testing. The tool's endpoint is clear, with connection and event controls on the left and communication logs on the right, giving you a comprehensive view of all event interactions.

The tool supports custom events and arguments, and can format JSON data for easy viewing of complex data structures. It also provides real-time connection status indicators, keeping you informed about server connectivity. When connection issues arise, Socket.IO Inspector displays detailed error messages to help quickly identify problems.

For temporary testing needs, Socket.IO Inspector is an excellent choice. You don't need to install any software – just open a browser to start testing. This is particularly useful for multi-device testing or quick server function verification in different environments.

However, as an online tool, Socket.IO Inspector may not match some professional desktop tools in workflow integration and advanced features. Nevertheless, its immediate availability and support for all Socket.IO versions make it highly practical, especially for quick testing or environments where installation permissions are limited.

Postman

Tool Name	Postman
Free?	Yes
URL	https://www.postman.com/

Postman is a widely popular API development tool that supports not only conventional HTTP request testing but also WebSocket and Socket.IO. As a mature API development platform, Postman offers professional-grade functionality for Socket.IO testing.

However, compared to tools specifically designed for Socket.IO, Postman may not be as intuitive in supporting certain Socket.IO-specific features. But for teams already using Postman for API development, its uniformity and integration capabilities represent a tremendous advantage, allowing all API-related testing to be completed within a single tool.

Summary

Socket.IO, as a powerful real-time communication library, requires appropriate tools to assist with development and debugging. Among the 5 recommended tools, Apidog undoubtedly stands as the most versatile and professional choice. It not only provides complete Socket.IO debugging functionality but also seamlessly integrates with other API development work, truly delivering an "All in One" development experience.

While the other tools each have their own characteristics, most only solve part of the problem: WebSocket King is simple to operate but limited in functionality; Socket.IO Test Client is convenient as a browser plugin but doesn't support team collaboration; Socket.IO Inspector requires no installation but is difficult to manage systematically; Postman is feature-rich but not as intuitive or comprehensive in Socket.IO-specific support as Apidog.

For project teams looking to enhance development efficiency and strengthen team collaboration, Apidog's advantages are particularly evident. It not only meets daily Socket.IO debugging needs but also provides endpoint saving, team sharing, documentation generation, and other features that make the entire development process more standardized and efficient. Especially in large projects, being able to uniformly manage HTTP, WebSocket, and Socket.IO endpoints eliminates the hassle of switching between multiple tools.

If you're looking for a Socket.IO debugging tool that satisfies both personal development needs and supports team collaboration, Apidog is definitely your first choice. With its continuously improving features and active community support, Apidog is becoming a new standard in the API development field.

10 Markdown Tips for Creating Beautiful Product Documentation in 2025

How to Run AI Models Locally with Ollama: Deploy LLMs and Debug APIs in Minutes

Auden — Fri, 07 Mar 2025 10:25:35 +0000

This article introduces how to download Ollama and deploy AI large language models (such as DeepSeek-R1, Llama 3.2, etc.). Using Ollama - an open-source large language model service tool - you can run other open-source AI models locally on your computer. We'll provide step-by-step instructions for installation and setup to enable seamless interaction with AI models.

Table of Contents

Step 1: Download and Install Ollama

Step 2: Install AI Models

Step 3: Interact with AI Models

Step 4: Optional - Simplify Workflows with GUI/Web Tools

Step 5: Debug the Local AI API

Step 1: Download and Install Ollama

Visit Ollama's official GitHub repository: https://github.com/ollama/ollama
Download the version corresponding to your operating system (this tutorial uses macOS as an example; Windows follows similar steps).

3.Complete the installation.

After installation, open the Terminal (on macOS, press F4 and search for "Terminal"). Enter ollama - if the following prompt appears, installation was successful.

Step 2: Install AI Models

After installing Ollama, download the desired AI model using these commands:

ollama run Llama3.2

Available models (replace Llama3.2 with your preferred model):

Model	Parameters	Size	Download
DeepSeek-R1	7B	4.7GB	`ollama run deepseek-r1`
DeepSeek-R1	671B	404GB	`ollama run deepseek-r1:671b`
Llama 3.3	70B	43GB	`ollama run llama3.3`
Llama 3.2	3B	2.0GB	`ollama run llama3.2`
Llama 3.2	1B	1.3GB	`ollama run llama3.2:1b`
Llama 3.2 Vision	11B	7.9GB	`ollama run llama3.2-vision`
Llama 3.2 Vision	90B	55GB	`ollama run llama3.2-vision:90b`
Llama 3.1	8B	4.7GB	`ollama run llama3.1`
Llama 3.1	405B	231GB	`ollama run llama3.1:405b`
Phi 4	14B	9.1GB	`ollama run phi4`
Phi 4 Mini	3.8B	2.5GB	`ollama run phi4-mini`
Gemma 2	2B	1.6GB	`ollama run gemma2:2b`
Gemma 2	9B	5.5GB	`ollama run gemma2`
Gemma 2	27B	16GB	`ollama run gemma2:27b`
Mistral	7B	4.1GB	`ollama run mistral`
Moondream 2	1.4B	829MB	`ollama run moondream`
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`
LLaVA	7B	4.5GB	`ollama run llava`
Granite-3.2	8B	4.9GB	`ollama run granite3.2`

A progress indicator will appear during download (duration depends on internet speed):

When prompted with "Send a message", you're ready to interact with the model:

Step 3: Interact with Llama3.2

Example interaction (asking "Who are you?"):

Use Control + D to end the current session.
To restart later, simply rerun ollama run Llama3.2.

Step 4: Optional GUI/Web Interface Support

Using a terminal for daily interactions can be inconvenient. For a more user-friendly experience, Ollama’s GitHub repository lists multiple community-driven GUI and web-based tools (e.g., Ollama WebUI, LM Studio). You can explore these options independently, as each project provides its own setup instructions. Here’s a brief overview:

GUI Tools
- Ollama Desktop : Native app for macOS/Windows (supports model management and chat).
- LM Studio : Cross-platform interface with model library integration.
Web Interfaces
- Ollama WebUI : Browser-based chat interface (run locally).
- OpenWebUI : Customizable web dashboard for model interaction.

For details, visit the Ollama GitHub README .

Step 5: Debug the AI API

Ollama exposes a local API by default. Refer to the Ollama API Docs for details.

Create a New Request

Copy this cURL command:

curl --location --request POST 'http://localhost:11434/api/generate' \
--header 'Content-Type: application/json' \
--data-raw '{
    "model": "llama3.2",
    "prompt": "Why is the sky blue?",
    "stream": false
}'

In Apidog:

Create a new HTTP project.
Paste the cURL into the request builder.
Save the configuration.

Send the Request

Navigate to the "Run" tab and click "Send". The AI response will appear.

For streaming output, set "stream": true.

Conclusion

This guide covered:

Ollama installation
Model deployment
Command-line interaction
API testing with Apidog

You now have a complete workflow for local AI model experimentation and application development.

References

No Database? No Problem! Build Local Mock APIs with JSON Server

Auden — Thu, 27 Feb 2025 09:58:17 +0000

A Mock service simulates backend API data, enabling frontend developers to rapidly debug pages or test various data scenarios. This article demonstrates how to build a local Mock service in three simple steps using JSON Server, requiring only a JSON file and no database setup!

Table of Contents

1. Prerequisites

Install Node.js

Install JSON Server

2. Building the Mock Service

Step 1: Create a Mock Data File (db.json)

Step 2: Start the JSON Server

Step 3: Verify API Endpoints

3. Debugging and Extensions

Auto-Update Data

Debugging with Apidog

4. FAQ

Port Conflicts

Data Not Updating

5. Conclusion

I. Prerequisites

1. Install Node.js

Ensure Node.js is installed (download from https://nodejs.org).

Verify by running in terminal:

node -v && npm -v

If version numbers are displayed, installation is complete.

2. Install JSON Server

Open the terminal in your IDE (e.g., VS Code) and execute:

npm install -g json-server

If permission errors occur, try:

sudo npm install -g json-server

II. Building the Mock Service in 3 Steps

Step 1: Create a Mock Data File

Create a folder (e.g., mock-demo) and add a db.json file with the following content:

{
  "users": [
    { "id": 1, "name": "John Doe", "age": 25 },
    { "id": 2, "name": "Jane Smith", "age": 30 }
  ],
  "posts": [
    { "id": 1, "title": "First Post", "author": "John Doe" }
  ]
}

📝 Explanation:

users and posts represent two API endpoints.
Each endpoint returns an array of data; fields can be freely added/removed.

Step 2: Start the Service

Navigate to the project folder in terminal:

cd ~/Desktop/mock-demo

Start the server with:

json-server --watch db.json --port 3000

🔍 Parameter Details:

--watch: Auto-reloads when db.json changes.
--port 3000: Runs the service on port 3000 (customizable).

Successful startup will display:

Endpoints:
http://localhost:3000/users
http://localhost:3000/posts

Step 3: Verify Endpoints

Open a browser and visit:

User list: http://localhost:3000/users
Post list: http://localhost:3000/posts

III. Debugging and Extensions

1. Auto-Update Data

Edit db.json and save—the changes will reflect immediately upon refreshing the page.

2. Debugging with Apidog

Apidog is a modern API collaboration tool supporting debugging, mocking, and documentation. Follow these steps to test your Mock service:

Step 1: Install Apidog

Download: Install the desktop app from Apidog Official Site.
Sign Up: Use email for quick registration.

Step 2: Create a Debugging Project

New Project: Click "Create Project" → Name it (e.g., "Mock Service Test") → Select "Blank Template".
Add Request: Go to "APIs" → "New Endpoint" → Name it (e.g., "Fetch User List").

Step 3: Send a GET Request

Configure:

Method: GET
URL: http://localhost:3000/users

Send: Click "Send" to view the response:

[
  { "id": "1", "name": "John Doe", "age": 25 },
  { "id": "2", "name": "Jane Smith", "age": 30 }
]

Error messages can be ignored.

Step 4: Send a POST Request (Add Data)

Configure:

Method: POST
URL: http://localhost:3000/users
Body (JSON):

{
  "name": "Alice Johnson",
  "age": 28
}

Response:

{
  "id": "a69a",
  "name": "Alice Johnson",
  "age": 28
}

Step 5: Verify Data Persistence

Resend the GET request to see the new entry:

[
  { "id": "1", "name": "John Doe", "age": 25 },
  { "id": "2", "name": "Jane Smith", "age": 30 },
  { "id": "a69a", "name": "Alice Johnson", "age": 28 }
]

Step 6: Advanced Operations (Optional)

PUT: Update data (e.g., http://localhost:3000/users/2).
DELETE: Remove data (e.g., http://localhost:3000/users/2).

Why Choose Apidog?

✅ No Manual Configuration: Auto-saves request history.

✅ Visual Data Display: Auto-formats JSON responses.

✅ Team Collaboration: Share documentation with one click.

✅ Enhanced Mocking: Generate dynamic data (e.g., random names, timestamps).

With Apidog, you can manage all APIs as effortlessly as building blocks and auto-generate documentation with a single click, doubling frontend-backend collaboration efficiency! 🚀

FAQ

Q1: Port already in use?

Change the port via --port 4000 in the startup command.

Q2: Data not updating?

Validate db.json syntax using JSONLint.

Conclusion

With JSON Server, you can create a fully functional Mock service using just a JSON file, supporting RESTful CRUD operations. It’s an ideal zero-cost solution for frontend debugging and demos. You now have a local API service—start integrating it into your projects today! 🚀

How to Run AI Models Locally with Ollama: Deploy LLMs and Debug APIs in Minutes