Nodejs on David Lang

Introduction to LangChain: Building AI-Powered Apps

Wed, 08 Mar 2023 00:00:00 +0000

LangChain composes LLM calls with prompts, memory, tools, and retrieval. It standardizes patterns that every AI app eventually needs.

Chains and Prompts

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer as a senior engineer."),
    ("user", "{question}"),
])
chain = prompt | llm
response = chain.invoke({"question": "What is RAG?"})

Retrieval

Load documents, chunk text, embed with OpenAI or open models, store in a vector DB, and retrieve relevant chunks at query time-foundation for RAG systems.

Getting Started with the OpenAI API in Node.js

Thu, 12 Jan 2023 00:00:00 +0000

The OpenAI API brought large language models to application developers through a simple HTTP interface. Node.js remains a natural fit for BFF layers that call LLMs.

Installation and First Request

npm install openai

import OpenAI from 'openai';

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const completion = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful coding assistant.' },
    { role: 'user', content: 'Explain async/await in JavaScript.' },
  ],
});

console.log(completion.choices[0].message.content);

Production Considerations

Never expose API keys in frontend bundles. Proxy requests through your backend. Set max_tokens, timeouts, and retry policies. Log token usage for cost control.

Prisma ORM: Modern Database Access in Node.js

Tue, 07 Dec 2021 00:00:00 +0000

Prisma provides type-safe database access, migrations, and a visual data browser-popular in TypeScript full stack projects.

Schema Definition

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id       String @id @default(cuid())
  title    String
  author   User   @relation(fields: [authorId], references: [id])
  authorId String
}

Queries

const users = await prisma.user.findMany({
  include: { posts: true },
  where: { email: { contains: '@company.com' } },
});

Migrations

npx prisma migrate dev applies schema changes in development. Use prisma generate after schema edits to refresh the client.

MongoDB Best Practices: Schema Design and Indexing

Mon, 25 Oct 2021 00:00:00 +0000

MongoDB’s flexible documents are powerful-but schema design still matters for performance and maintainability.

Embedding vs Referencing

Embed when data is read together and has a one-to-few relationship (user preferences inside a user doc). Reference when data grows unbounded or is shared (comments on posts).

Indexing

db.orders.createIndex({ customerId: 1, createdAt: -1 });

Compound indexes support queries that filter and sort on the same fields. Use .explain() to verify index usage.

Validation and Migrations

Use JSON Schema validation at the collection level. Version documents with a schemaVersion field for gradual migrations.

WebSockets with Node.js: Real-Time Applications

Wed, 30 Jun 2021 00:00:00 +0000

WebSockets provide full-duplex communication over a single TCP connection-ideal for chat, live dashboards, and collaborative editing.

Socket.io Setup

const { Server } = require('socket.io');
const io = new Server(httpServer, { cors: { origin: process.env.CLIENT_URL } });

io.on('connection', (socket) => {
  socket.on('join-room', (roomId) => socket.join(roomId));

  socket.on('message', (payload) => {
    io.to(payload.roomId).emit('message', payload);
  });
});

Scaling Considerations

Use Redis adapter for Socket.io when running multiple server instances. Sticky sessions or shared pub/sub keep room state consistent.

Building Microservices with Node.js

Sat, 22 May 2021 00:00:00 +0000

Microservices split a system into independently deployable services. Node.js is a common choice for I/O-bound services, BFF layers, and event-driven workers.

Service Boundaries

Split by business capability-not by technical layer. A orders service owns order data; a notifications service sends email. Communicate via REST, gRPC, or message queues (RabbitMQ, Kafka).

Resilience Patterns

Implement timeouts, retries with exponential backoff, and circuit breakers. Use correlation IDs across services for distributed tracing (OpenTelemetry).

JWT Authentication: Securing Your REST API

Sat, 05 Sep 2020 00:00:00 +0000

JSON Web Tokens (JWT) are a compact way to represent claims between parties. For stateless REST APIs and SPAs, JWT-based auth is a standard pattern-when implemented correctly.

Token Structure

A JWT has three Base64-encoded parts: header, payload, and signature. The server signs the token with a secret (HS256) or private key (RS256). Clients send Authorization: Bearer <token> on each request.

Issuing Tokens in Node.js

const jwt = require('jsonwebtoken');

function login(req, res) {
  const user = validateCredentials(req.body);
  if (!user) return res.status(401).json({ error: 'Invalid credentials' });

  const token = jwt.sign(
    { sub: user.id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '1h' }
  );
  res.json({ token });
}

Middleware Verification

function authMiddleware(req, res, next) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer ')) return res.sendStatus(401);
  try {
    req.user = jwt.verify(header.slice(7), process.env.JWT_SECRET);
    next();
  } catch {
    res.sendStatus(401);
  }
}

Security Checklist

Keep secrets out of source control. Use short expiration and refresh tokens for long sessions. Never store sensitive data in the payload-it is readable. Prefer HTTPS everywhere.

Introduction to GraphQL: Why It Matters

Sat, 25 Jul 2020 00:00:00 +0000

GraphQL is a query language for APIs that lets clients request exactly the fields they need. Unlike REST, you avoid over-fetching and under-fetching by design.

Schema-First Design

type Query {
  user(id: ID!): User
  posts(limit: Int = 10): [Post!]!
}

type User {
  id: ID!
  name: String!
  posts: [Post!]!
}

Clients send queries that mirror the shape of the response:

query {
  user(id: "1") {
    name
    posts(limit: 5) { title createdAt }
  }
}

Server Implementation

Apollo Server and GraphQL Yoga are popular in Node.js. Resolvers map fields to databases or microservices. Use DataLoader to batch N+1 queries.

Docker for Developers: Containerizing Your Node.js App

Sat, 30 May 2020 00:00:00 +0000

Docker packages your application and its dependencies into a portable image. For Node.js APIs and React frontends, containers ensure dev, CI, and production environments behave the same way.

A Production-Ready Dockerfile

Multi-stage builds keep images small:

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
ENV NODE_ENV=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

docker-compose for Local Dev

Pair your API with PostgreSQL or Redis:

Building REST APIs with Node.js and Express

Sun, 22 Mar 2020 00:00:00 +0000

Express remains the most popular framework for building REST APIs in Node.js. It is minimal, unopinionated, and pairs well with middleware for auth, validation, and logging.

Project Setup

Initialize a project and install Express:

npm init -y
npm install express

Create a basic server with JSON body parsing:

const express = require('express');
const app = express();
app.use(express.json());

const items = [];

app.get('/api/items', (req, res) => res.json(items));

app.post('/api/items', (req, res) => {
  const item = { id: Date.now(), ...req.body };
  items.push(item);
  res.status(201).json(item);
});

app.listen(3000, () => console.log('API running on :3000'));

Structure for Production

Organize routes by resource (/users, /orders), use a router per domain, and separate controllers from route definitions. Add helmet for security headers, cors for cross-origin access, and a centralized error handler that returns consistent JSON error shapes.