DEV Community: Manendra Verma

Setup Appwrite Storage with NestJS (Step-by-Step Guide)

Manendra Verma — Thu, 19 Mar 2026 14:50:32 +0000

Setup Appwrite Project

Step 1 — Create an Appwrite Project

Go to cloud.appwrite.io and sign up / log in
Create a new project (e.g. "Neutter")
Copy your Project ID from the project settings

Step 2 — Create a Storage Bucket

In the Appwrite console, go to Storage → Create Bucket
Name it something like files
Set permissions:
- For now, allow Any to read (so files can be viewed)
- Allow Any to create (your server will upload on behalf of users)
Copy the Bucket ID

Step 3 — Get an API Key

Go to Settings → API Keys → Create API Key
Give it Storage permissions (read, write, delete)
Copy the API Key

Setup NestJS Project

Step 1 — Create project

npm i-g @nestjs/cli
nest new backend
cd backend

Step 2 — Create Storage Module

nest g module AppwriteService
nest g service AppwriteService
nest g controller AppwriteService

Step 3 — Install the SDK

npm install node-appwrite
npm install multer
npm install --save-dev @types/multer

Step 4 — Add to your `.env`

APPWRITE_ENDPOINT=https://cloud.appwrite.io/v1
APPWRITE_PROJECT_ID=your-project-id
APPWRITE_API_KEY=your-api-key
APPWRITE_BUCKET_ID=your-bucket-id

Step 4 — Configure Appwrite SDK

// src/appwrite/appwrite.service.ts
import { Injectable } from '@nestjs/common';
import { Client, Storage } from 'node-appwrite';

@Injectable()
export class AppwriteService {
  private client: Client;
  private storage: Storage;

  constructor() {
    this.client = new Client()
      .setEndpoint('https://<REGION>.cloud.appwrite.io/v1') // Replace with your Appwrite endpoint
      .setProject('<PROJECT_ID>')                           // Replace with your project ID
      .setKey('<API_KEY>');                                 // Replace with your API key

    this.storage = new Storage(this.client);
  }

  // add below wpload function here
}

Step 5 — Create Upload function

async uploadFile(file: Express.Multer.File) {
    try {
     const result = await this.storage.createFile(
      process.env.APPWRITE_BUCKET_ID!,
      ID.unique(),
      InputFile.fromBuffer(file.buffer, file.originalname)   // wraps buffer + filename
    );

   const fileUrl = `${process.env.APPWRITE_ENDPOINT}/storage/buckets/${process.env.APPWRITE_BUCKET_ID}/files/${result.$id}/preview?project=${process.env.APPWRITE_PROJECT_ID}`; 
      return { 
        message: 'File uploaded successfully', 
        fileId: result.$id, 
        url: fileUrl, 
      };

    } catch (error) {
      throw new InternalServerErrorException('Failed to upload file');
    }
  }

Step 6 — Setup Controller

import {
  Controller,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { AppwriteServiceService } from './appwrite-service.service';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('appwrite-service')
export class AppwriteServiceController {
  constructor(
    private readonly appwriteService: AppwriteService,
  ) {}

  @Post('upload')
  @UseInterceptors(FileInterceptor('file'))
  async uploadFile(@UploadedFile() file: Express.Multer.File) {
    console.log("file dta:", file)
    return this.appwriteServiceService.uploadFile(file);
  }
}

Step 7 — Setup Configuration

Depending on the environment, different configuration settings should be used.

npm i --save @nestjs/config

Now in app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AppwriteServiceModule } from './appwrite-service/appwrite-service.module';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({      // add this part
      isGlobal: true,
    }),
    AppwriteServiceModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Step 8 — Test is using postman

Final Thoughts

Integrating Appwrite Storage with NestJS gives you a clean, scalable way to manage files without dealing with infrastructure complexity.

With just a few steps, you now have:

File upload API
Secure storage
File preview links

Integrating Appwrite Storage with NestJS is a practical and efficient way to handle file management in your backend applications. With just a few configurations, you can offload complex storage logic and focus more on building core features.

Using Appwrite not only simplifies file handling but also provides scalability, security, and ease of use — making it an excellent choice for modern full-stack development.

How to Run ClawBot Locally Using LM Studio (Free Setup Guide)

Manendra Verma — Tue, 10 Mar 2026 13:53:04 +0000

This article explains how you can set up ClawBot locally using LM Studio and run it on your own machine without relying on paid APIs.

By connecting ClawBot to LM Studio, you can use local AI models to test and perform basic development tasks while keeping everything private and under your control.

Since everything runs on your own machine, you get full control and privacy over your data. I tested this setup myself and it works well for experimentation and learning.

Quick Reminder:

This setup is mainly for testing and basic tasks.
Running AI models locally requires a decent system with good CPU or GPU performance.
You should have at least 16 GB RAM (32 GB recommended for smoother performance).
For complex tasks, a system with strong GPU or higher CPU power will work much better.
The setup is completely free, but remember that the model runs on your own system resources.

Before starting, it’s important to understand the limitations and requirements of running everything locally.

Minimum Hardware (Basic Setup)

This will run 7B models like Qwen2.5-Coder-7B-Instruct.

CPU: modern 4–6 core CPU (Intel i5 / Ryzen 5 or better)
RAM: 16 GB recommended
Storage: 10–20 GB free space
GPU: optional (can run on CPU)

Performance:

speed: ~5–10 tokens/sec on CPU
usage: good for chat and testing agents

Recommended Hardware (Smooth Experience)

For faster inference and multiple tools.

CPU: 8+ core processor (Ryzen 7 / i7)
RAM: 32 GB
GPU: 8–12 GB VRAM (RTX 3060 / 4060 / 4070)
Storage: SSD required

Performance:

speed: 20–60 tokens/sec
latency: much lower
agent tasks: smoother

Step By Step Guide

Phase-1 — Install LM Studio

LM Studio runs the local model.

Go to the official website

https://lmstudio.ai
Download LM Studio for Windows
Install normally.
Open LM Studio

Phase-2 — Download a model

Inside LM Studio:

Left sidebar -> Model Search (4th icon)

Example search:

Qwen2.5-Coder-7B-Instruct

NOTE: Just above the download button you can select the Quantization of the model

Step-2.1: How to select the Right Model

Selecting the best model in LM Studio depends on several technical factors: hardware capacity, task type, model size, and quantization.

1. Check Your Hardware First:

Your RAM and GPU VRAM determine what models can run efficiently.

Typical guidelines:

Hardware	Recommended Model Size
8 GB RAM	3B–4B models
16 GB RAM	7B–8B models
32 GB RAM	13B models
64 GB RAM	30B+ models

Meaning of the “B”

B = Billion

Examples:

7B  = 7 Billion parameters
6.7B = 6.7 Billion parameters
34B = 34 Billion parameters
70B = 70 Billion parameters

So a 7B model has about 7,000,000,000 parameters.

Example Model Sizes
Small models
1B – 3B
Fast but weaker reasoning

Medium models
7B – 8B
Good balance of speed and intelligence

Large models
13B – 34B
Much smarter but need strong hardware

Very large models
70B+
Need powerful GPUs or servers

2. Choose Model Based on Task

Different models are trained for different tasks.

Coding

Best model types:

Qwen2.5-Coder
DeepSeek-Coder
CodeLlama

Content Writing / Chat

Llama 3.1
Mistral
Qwen2.5

Reasoning / Agents

DeepSeek-R1 Distill
Qwen2.5
Ministral

3. Pick the Right Quantization

Quantization controls memory usage vs quality.

Common options:

Quantization	Quality	RAM Usage
Q2	low	very small
Q3	medium-low	small
Q4_K_M	good	moderate
Q5_K_M	very good	higher
Q6/Q8	near original	large

Best default choice:

Q4_K_M

quality: very good
speed: fast
memory: manageable

4. Choose Trusted Model Publishers

The same model can appear from multiple uploaders.

Prefer models published by:

Llama family
Qwen family
Mistral family
DeepSeek family

Phase-3 — Load the Model

In the server panel click:

Load Model

Select your downloaded model.

Once loaded you should see it listed under:

Loaded Models

NOTE: Must enable (Manually choose model load parameters)

Put context length low as possible because it will affect response time.

Low context length → Fast response but loose accuracy
high context length → Slow response but high accuracy
GPU offloading decides how many of those layers run on the GPU instead of the CPU.

If your system has no GPU, set:

GPU Offload = 0

If GPU offload = 0 layers: CPU does all calculations.

LLMs are built with layers (like 32–40 layers depending on the model).

Example:

Total layers in model = 32

If you set:

GPU Offload = 10

Then:

10 layers → GPU
22 layers → CPU

So the workload is shared.

Phase-4 — Start LM Studio Local API Server

1. Open LM Studio

Launch LM Studio on your computer.

2. Open Developer Settings

Look at the left sidebar: usually ****(third icon from the top)

In your sidebar click the icon that looks like:

>_

This is the Developer / API panel.

3. Open the Local Server Panel

first option in in Developer sidebar

4. Keep Server Setting like this

5. Start the Server

Click:

toggle the button before server setting

You should see:

Server running at URL comes next to it check it.

Open browser:

http://localhost:1234/v1/models
or
http://172.25.64.1:1234/v1/models

If you see JSON with your model → LM Studio is working.

Example response:

{
  "data": [
    {
      "id": "qwen2.5-coder-7b-instruct",
      "object": "model",
      "owned_by": "organization_owner"
    },
    {
      "id": "text-embedding-nomic-embed-text-v1.5",
      "object": "model",
      "owned_by": "organization_owner"
    }
  ],
  "object": "list"
}

Phase-5 — Install OpenClaw

OpenClaw requires Node.js 22 as a prerequisite. Don't worry—installation is automated.

Universal Installation (All Platforms):

Open your terminal/command prompt and run this single command:

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

If that doesn't work, or you're on Windows PowerShell, use:

iwr -useb https://openclaw.ai/install.ps1 | iex

Open PowerShell as Administrator:

If install as admin then it will automatically configure the gateway.
If it asks anywhere Remote or Local, then set it as local.

Phase-6 — Configure OpenClaw to Use LM Studio

After running make sure you select like these:

Other things you can select skip for now option, or you can setup later any of those you want to. I’ll setup later.

You get base URL and LLM model from the right sidebar of LM studio in info tab. Use yours not copy paste it. you can only use the API KEY as same as mine.

You will asked about following field: (here what I select)

Default model: Keep current (vllm/qwen2.5-coder-7b-instruct)
Channel status: skip for now
Search provider: Skip for now
Configure skills now?: No
Enable hooks? No
Optional apps: skip for now
Control UI: Web UI

Phase-7 — Run OpenClaw

After completion of above command you get a URL like this:

http://127.0.0.1:18789/#token=YOUR-Token

Now copy the URL and paste it any browser search bar. You get the chat interface like this

Now you can use the claw bot here.

Or, you can run using command:

openclaw gateway

Phase-8 — Now if you want to remove clawbot from the system entirely

For security reasons if you don't want to use claw bot follow following steps to remove clawbot from the system:

Step-1: Stop the Running Server

If OpenClaw is running in the terminal:

Ctrl + C

Step-2: Delete the OpenClaw Project Folder

Go to the following path:

C:\Users\youname

Delete the .openclaw folder.

Now, Work is not done yet. You have to delete packages too.

Step-3: Remove Global Packages

Check global packages:

npm list -g --depth=0

If you see something like:

openclaw

remove it:

npm uninstall -g openclaw

Usually, this step is not required because OpenClaw runs locally.

Step-4: Remove Local Models

If you downloaded models for LM Studio, they are stored separately.

Location (Windows):

C:\Users\<your-user>\.lmstudio\models

Delete models if you want to free space.

Step-5: Clear Node Cache (Optional)

This step is optional but removes leftover npm cache.

npm cache clean --force

Reminder:

It is only for testing and perform basic tasks.
You need large system which has more GPU or CPU power to perform complex task.
This is entirely free so you can use it but keep in mind that it is using your system resources to run.

----- 📄 Document Ends Here. Thanks for Reading!!! 🎉 -----

How to Setup NestJS with Prisma and PostgreSQL (2026 Complete Guide)

Manendra Verma — Tue, 03 Mar 2026 14:13:36 +0000

Step-1: Create NestJS Project

Install the NestJS CLI and create a new project:

npm install -g @nestjs/cli

nest new nestjs-prisma

When prompted, select npm as your package manager. Navigate to the project directory:

cd nestjs-prisma

Step-2: Setup Prisma

Install Dependencies: Install the necessary Prisma packages and database drivers:

npm install prisma --save-dev

npm install @prisma/client @prisma/adapter-pg pg

Step-2.1: Initialize Prisma

Initialize Prisma in your project:

npx prisma init --output ../src/generated/prisma

It will also set the client output from "../generated/prisma” to “../src/generated/prisma”

Step-2.2: Set the generator output path

Note: Specify your output path for the generated Prisma client by either passing --output ../src/generated/prisma during prisma init

generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

Step-2.3: Configure the module format #

generator client {
  provider        = "prisma-client"
  output          = "../src/generated/prisma"
  moduleFormat    = "cjs"
}

Note: The moduleFormat configuration is required because Prisma v7 ships as an ES module by default, which does not work with NestJS's CommonJS setup. Setting moduleFormat to cjs forces Prisma to generate a CommonJSmodule instead of ESM.

Step-3: Configure PostgreSQL Connection

Edit .env

DATABASE_URL="postgresql://postgres:password@localhost:5432/nestdb?schema=public"

Step-4: Define your data model

Add the following two models to your schema.prisma file:

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}
model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean? @default(false)
  author    User?    @relation(fields: [authorId], references: [id])
  authorId  Int?
}

Step-5: Run Migration

npx prisma migrate dev --name init

Step-6: Generate Prisma Client

Once installed, you can run the generate command to generate the types and Client needed for your project.

npx prisma generate

Step-7: Create a Prisma service

nest g module prisma

nest g service prisma

Inside the src directory, create a new file called prisma.service.ts and add the following code to it:


import { Injectable } from "@nestjs/common";
import { PrismaClient } from "../generated/prisma/client.js";
import { PrismaPg } from "@prisma/adapter-pg";

@Injectable()
export class PrismaService extends PrismaClient {
  constructor() {
    const adapter = new PrismaPg({
      connectionString: process.env.DATABASE_URL as string,
    });
    super({ adapter });
  }
}

Step-8: Register services in the app module (Optional)

Remember to register the new services in the app module.

Optional: If you create a module for prisma service. Otherwise paste below code.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { PrismaService } from './prisma/prisma.service';

@Module({
  imports: [PrismaModule],
  controllers: [AppController],
  providers: [AppService, PrismaService],
})
export class AppModule {}

Step-9: Test Setup

npm run start
or
npm run start:dev

Step-10: Create services

Now create services and use it like you do in normal Nest app.

----- 📄 Document End 🎉 -----

How to Actually Learn Backend in 2026

Manendra Verma — Fri, 06 Feb 2026 15:45:44 +0000

When people start learning backend development, one of the most common mistakes they make is getting attached to a single programming language or framework. They think learning Node.js, Django, or Spring Boot means they are learning backend development.

But backend development is much bigger than any one language or framework.

Backend Is About Concepts, Not Syntax

If you look closely, most backend systems—no matter what language they are written in—share the same core ideas.

Things like:

Authentication
Authorization
Validation
Middleware
Database interactions
Error handling
API design

These concepts exist everywhere.

Whether you are using Node.js, Java, Python, Go, or PHP, you will always need to:

Authenticate users
Validate incoming data
Protect routes
Handle errors gracefully
Structure your application logically

The syntax changes, but the thinking does not.

Just Like Learning Programming Fundamentals

Think about how we learn programming languages.

When you first learned to code, you didn’t memorize just JavaScript or C++ syntax. You learned:

Variables
Functions
Conditions
Loops
Data structures

These ideas are common to almost every programming language. Once you understand them, switching from one language to another becomes easier because only the syntax changes.

Backend development works the same way.

Focus on What, How, and When

Instead of asking:

“How do I implement authentication in Node.js?”

Try asking:

What is authentication?
How does authentication work internally?
When should I use sessions vs tokens?
Why is middleware useful?

When you focus on how these systems function, you start seeing patterns that apply everywhere. That’s when backend development truly makes sense.

Transferable Knowledge Is Real Power

When you learn backend as a set of concepts:

You can switch frameworks faster
You can read large backend codebases with confidence
You can debug issues more effectively
You don’t feel lost when the stack changes

A developer who understands backend fundamentals can jump from Express to Django or from Spring Boot to Go-based services without starting from zero.

Learn Backend the Right Way

So if you’re learning backend:

Don’t just follow tutorials blindly
Don’t tie your identity to a single framework
Focus on why something exists, not just how to write it

Learn backend in a way that your knowledge becomes portable, scalable, and future-proof.

That’s how you grow from a framework user into a backend engineer. 🚀