Forem: Ramandeep Singh

Online Assembly Language Learning Resources

Ramandeep Singh — Thu, 23 Apr 2026 04:21:39 +0000

In case traditional assembly tools (NASM, GCC) are not installed on your local system, here are online alternatives that you can use immediately:

Online Assembly Compilers & Simulators

1. Compiler Explorer (Godbolt)

URL: https://godbolt.org/
Features:
- Supports x86-64, ARM, and other architectures
- Real-time compilation and assembly output
- Multiple compiler options (GCC, Clang, MSVC)
- Interactive assembly learning

2. OnlineGDB

URL: https://www.onlinegdb.com/
Features:
- Online C/C++ compiler with assembly output
- Debugging capabilities
- Multiple language support

3. Replit

URL: https://replit.com/
Features:
- Online IDE with NASM support
- Collaborative coding
- Multiple programming languages

4. TutorialsPoint Online Compiler

URL: https://www.tutorialspoint.com/compile_assembly_online.php
Features:
- Dedicated assembly compiler
- Simple interface
- Good for beginners

Learning Platforms

1. Assembly Language Tutorials

CS50 Harvard: https://cs50.harvard.edu/x/2023/notes/4/
MIT OpenCourseWare: Assembly language courses
YouTube: Search for "assembly language tutorial"

2. Interactive Learning

Codecademy: Assembly language basics
Coursera: Computer architecture courses
edX: MIT and other university courses

Quick Start with Online Tools

Using Compiler Explorer:

Go to https://godbolt.org/
Select "x86-64 gcc" as compiler
Write a simple C program:

#include <stdio.h>
int main() {
    printf("Hello, World!\n");
    return 0;
}

View the assembly output in the right panel
Experiment with different optimizations

Using OnlineGDB:

Go to https://www.onlinegdb.com/
Select "C" as language
Write your C program
Compile and run
Use the "Debug" feature to see assembly

Recommended Learning Path

Start with C to Assembly: Write simple C programs and examine the assembly output
Learn Basic Instructions: MOV, ADD, SUB, JMP, etc.
Understand Registers: AX, BX, CX, DX, etc.
Practice with Online Simulators: Use the tools above
Progress to Complex Programs: Loops, functions, system calls

Installation Guide (Optional)

If you want to install assembly tools locally:

Option 1: Install NASM and GCC

Download NASM from: https://www.nasm.us/
Install MinGW-w64 for GCC: https://www.mingw-w64.org/
Add to PATH environment variable

Option 2: Install Visual Studio

Download Visual Studio Community (free)
Install with C++ development tools
Use MASM (Microsoft Macro Assembler)

Option 3: Use WSL (Windows Subsystem for Linux)

Install WSL from Microsoft Store
Install Ubuntu or other Linux distribution
Install NASM and GCC in Linux environment

Building AI Agents Has Never Been This Easy: Meet Strands Agent SDK

Ramandeep Singh — Wed, 22 Apr 2026 08:19:34 +0000

Stop wrestling with complex agent frameworks. Start building intelligent AI agents in minutes, not weeks.

The Problem Every Developer Faces

Picture this: You've got a brilliant idea for an AI agent that can help your users. Maybe it's a customer support bot that actually understands context. Or a research assistant that can analyze documents and provide insights. Or perhaps a multi-agent system where specialized agents collaborate to solve complex problems.

You're excited. You start coding. And then... reality hits.

You spend days (or weeks) wrestling with:

Complex orchestration logic
Integrating multiple AI model providers
Building tool calling mechanisms from scratch
Managing agent state and memory
Setting up observability and monitoring
Coordinating multiple agents in a system

By the time you've built the infrastructure, you've forgotten why you started in the first place. The actual agent logic? That's buried under layers of boilerplate code.

There has to be a better way.

Enter Strands Agent SDK

The Strands Agent SDK is an open-source, model-driven framework that flips the script entirely. Instead of spending weeks building infrastructure, you can create production-ready AI agents in minutes.

Think of it as the difference between building a car from scratch versus having a well-designed chassis where you just add the engine and wheels. Strands gives you the chassis—robust, tested, and ready to go.

Why Strands Stands Out

🚀 Lightweight Yet Powerful

Most agent frameworks force you into rigid patterns. Strands gives you a clean, straightforward agent loop that works beautifully out of the box—but you can customize every part of it when you need to.

from strands import Agent
from strands_tools import calculator

# That's it. You just created an AI agent.
agent = Agent(tools=[calculator])
response = agent("What is the square root of 1764?")
print(response)  # "The square root of 1764 is 42."

No configuration files. No complex setup. Just import, create, and use.

🎯 Model Agnostic (Finally!)

Tired of being locked into one AI provider? Strands supports them all:

Amazon Bedrock - Access to Claude, Llama, Titan, and more
Anthropic - Direct Claude integration
OpenAI - GPT-4, GPT-3.5, and beyond
Google Gemini - Latest models from Google
Ollama - Run models locally
LiteLLM - Unified interface to 100+ models
Custom providers - Bring your own

Switch models with a single parameter change. Compare performance across providers. Never get vendor-locked again.

🤝 Multi-Agent Systems Made Simple

Here's where Strands really shines. Building multi-agent systems is notoriously complex. But with Strands, you can create agent swarms where each agent has a specialized role:

from strands import Agent

# Research agent
researcher = Agent(
    name="Researcher",
    role="Gather and analyze information"
)

# Creative agent
creator = Agent(
    name="Creator", 
    role="Generate creative content"
)

# Critic agent
critic = Agent(
    name="Critic",
    role="Review and provide feedback"
)

# They work together automatically

Agents can collaborate, share context, and build on each other's work. It's like having a team of specialists working together—except they're AI agents, and they never get tired.

🔧 Built-in MCP Support

The Model Context Protocol (MCP) gives you access to a vast ecosystem of pre-built tools. Need to search the web? Check the weather? Query a database? There's probably an MCP tool for it.

Strands has native MCP support, so you can leverage this entire ecosystem without writing custom integrations.

☁️ AWS-Native (But Not AWS-Only)

Strands originated from AWS, so it has deep integration with AWS services:

Amazon Bedrock - Seamless access to foundation models
AWS X-Ray - Distributed tracing for debugging
CloudWatch - Real-time monitoring and logging
Direct AWS service calls - Your agents can interact with DynamoDB, S3, Lambda, and more

But here's the thing: it works great outside AWS too. Use it with any provider, anywhere.

Real-World Use Cases

Customer Support Agent

from strands import Agent
from strands_tools import web_search, database_query

support_agent = Agent(
    name="SupportBot",
    tools=[web_search, database_query],
    instructions="You are a helpful customer support agent..."
)

# Handle customer queries
response = support_agent("I need help with my order #12345")

Research Assistant

research_agent = Agent(
    name="ResearchAssistant",
    tools=[web_search, calculator],
    instructions="Analyze information and provide insights..."
)

insights = research_agent(
    "Research the latest trends in renewable energy and summarize key findings"
)

Multi-Agent Content Creation

Create a team of agents that work together:

Researcher gathers information
Writer creates the content
Editor reviews and refines
Publisher formats and publishes

All coordinated automatically by Strands.

Getting Started in 5 Minutes

Step 1: Install

pip install strands-agents strands-agents-tools

Step 2: Create Your First Agent

from strands import Agent
from strands_tools import calculator

agent = Agent(tools=[calculator])

Step 3: Use It

result = agent("Calculate 15% of 250")
print(result)

That's it. You're now building AI agents.

What Makes This Different?

You might be thinking: "There are other agent frameworks. What makes Strands special?"

Here's the honest answer:

Simplicity without sacrificing power - Easy to start, powerful enough to scale
True model flexibility - Not just "we support multiple models" but "switch models like changing a variable"
Production-ready - Built with observability, monitoring, and debugging in mind
Active development - Open-source, actively maintained, with a growing community
AWS integration - If you're in the AWS ecosystem, the integration is seamless

The Future of Agent Development

We're at an inflection point. AI agents are moving from research projects to production systems. The frameworks that win will be the ones that let developers focus on what matters: building great agent experiences, not wrestling with infrastructure.

Strands Agent SDK is positioning itself as that framework. It's not trying to be everything to everyone. Instead, it's laser-focused on making agent development fast, flexible, and fun.

Ready to Build?

The best way to understand Strands is to use it. Start with a simple agent. Add a tool. Create a multi-agent system. You'll be surprised how quickly you can build something powerful.

Resources to get you started:

📚 Official Documentation - Comprehensive guides and API reference
💻 GitHub Repository - Source code, examples, and contributions
📖 AWS Blog Post - Technical deep dive
🎓 Examples and Tutorials - Step-by-step guides for common use cases

Your Turn

Have you built AI agents before? What was your experience? If you're new to agents, what would you want to build first?

Try Strands Agent SDK and let us know what you think. The barrier to entry has never been lower, and the possibilities have never been higher.

Happy building! 🚀

About the Author: This article introduces developers to the Strands Agent SDK, a powerful framework for building AI agents. Whether you're building your first agent or scaling to production, Strands makes the journey smoother.

Tags: #AI #MachineLearning #Agents #Python #AWS #OpenSource #DeveloperTools

Figma + Claude Code

Ramandeep Singh — Sat, 07 Mar 2026 10:55:46 +0000

Yes, Figma has officially partnered with Anthropic to integrate Claude AI capabilities into its design platform. Here are the key details:

Partnership and "Code to Canvas" Feature

Core Feature: "Code to Canvas" - converts AI-generated code from tools like Claude Code into fully editable Figma designs
Purpose: Bridges the gap between AI coding workflows and collaborative design refinement

How It Works

Build a UI using Claude Code in a browser-based environment
Capture the screen via the integration, which converts the live browser state into a Figma-compatible frame
Paste into Figma as an editable design artifact (not a flattened image)
Collaborate - teams can annotate, duplicate, rearrange, and compare AI-generated options directly on the canvas

Technical Setup

Runs on Figma's MCP (Model Context Protocol) Server, an open standard for connecting AI tools to external applications
Requirements:
- Figma desktop app (browser version not supported)
- Figma Dev or Full seat
- Claude Code installed via npm
Setup involves enabling the MCP server in Figma preferences and connecting it to Claude Code via a terminal command

Why It Matters

Benefit	Impact
Reverse workflow	Enables code -> design flow (traditionally design -> code)
Team collaboration	Non-technical stakeholders can review and give feedback on actual built UIs
Design system alignment	Check if AI-generated UIs match your existing components and tokens
Round-trip workflow	Design in Figma->Generate code with Claude
-> Capture back to Figma-> Refine

Limitations

Requires terminal / cli setup
Desktop app only (no browser support)
Multi-screen flows require individual captures
Claude Code operates directly in your codebase - changes affect production files
Token costs may add up for complex projects

Strategic Context

This partnership reflects Figma's bet that AI won't replace the design canvas - it will feed it with more options, faster.

ElevenLabs API key for Voices script.

Ramandeep Singh — Fri, 06 Mar 2026 04:40:44 +0000

1. Get an ElevenLabs API key

Create an account: https://elevenlabs.io
Log in and open Profile -> API Keys (or go to the developers/API keys page).
Click Create API Key.
Name the key (e.g. "PowerShell Script") and save it when shown.
Copy the key immediately as you won’t see the full value again; only the last 4 characters will be visible later.

2. Use the key in PowerShell

Send it in the xi-api-key header with every ElevenLabs API request.

Avoid hardcoding:

# Option A: Use environment variable (recommended)
$apiKey = $env:ELEVENLABS_API_KEY
# Set once: $env:ELEVENLABS_API_KEY = "your_key_here"

# Option B: Read from secure file (one-time setup: Read-Host -AsSecureString | ConvertFrom-SecureString | Out-File "elevenlabs.key")
$apiKey = (Get-Content "elevenlabs.key" | ConvertTo-SecureString).GetNetworkCredential().Password

# Option C: Prompt at runtime
$apiKey = Read-Host -Prompt "Enter ElevenLabs API Key" -AsSecureString
$apiKey = [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($apiKey))

Example API call:

$headers = @{
    "xi-api-key" = $apiKey
    "Content-Type" = "application/json"
}
Invoke-RestMethod -Uri "https://api.elevenlabs.io/v1/voices" -Headers $headers

3. Security

Add elevenlabs.key or similar files to .gitignore.
On ElevenLabs, you can restrict the key by feature and set credit limits.

Repository link - https://github.com/r123singh/ps-magic

Termux Commands — Quick Reference - Phone Hacks

Ramandeep Singh — Mon, 23 Feb 2026 13:32:37 +0000

Looking for terminal command experience on your phone? Here you go!

Local AI (SLMs)

Task	Command
Install Ollama	`curl -sL https://github.com/Anon4You/ollama-in-termux/raw/main/ollama.sh
Start Ollama server	{% raw %}`ollama serve &`
Run AI (1B/3B only)	`ollama run llama3.2:1b`
llama.cpp: deps	`pkg install clang cmake git`
llama.cpp: build	`git clone https://github.com/ggerganov/llama.cpp && cd llama.cpp && cmake -B build && cmake --build build --config Release`
llama.cpp: chat	`./build/bin/llama-cli -m models/your_model.gguf -p "Your prompt"`

Image viewing

Tool	Install	Use
tiv	`pkg install tiv`	`tiv image.jpg`
viu	`pkg install viu`	`viu image.jpg`
termimage	`pkg install termimage`	`termimage image.jpg`
Open in gallery	`pkg install termux-api`	`termux-open image.jpg`
ASCII art (retro)	`pkg install libcaca`	`cacaview image.jpg`

Image fetching & generation

Task	Command
Random Unsplash	`curl -L https://source.unsplash.com/random/1080x1080 -o random.jpg`
Topic image	`curl -L https://source.unsplash.com/featured/?topic,keyword -o file.jpg`
Placeholder	`curl https://via.placeholder.com/500x500.png?text=Text -o placeholder.png`
QR code	`pkg install qrencode` → `qrencode -o qr.png "https://url"`
ASCII fire	`pkg install libcaca` → `aafire`
Avatar	`curl https://robohash.org/username.png -o avatar.png`

Games

Install	Games
`pkg install bsdgames`	`snake`, `tetris-bsd`
`pkg install moon-buggy`	`moon-buggy`
`pkg install nethack`	`nethack`
`pkg install ninvaders`	`ninvaders`

Social & effects

Tool	Install	Use
Reddit (Reddix)	`pkg install reddix`	`reddix`
Matrix rain	`pkg install cmatrix`	`cmatrix`
Train easter egg	`pkg install sl`	`sl`
ASCII banner	`pkg install figlet`	`figlet "Hello"`
Fake hacker UI	`pkg install hollywood`	`hollywood`

Dashboard

pkg install tmux
tmux
# Split: Ctrl+b then %
# Pane 1: curl wttr.in/Phuket
# Pane 2: ping 8.8.8.8

Suggested models: Llama 3.2 (1B/3B), Gemma 2 (2B), Phi-3.5 Mini. Running AI can heat the phone.

AI Video creation - Models Research

Ramandeep Singh — Fri, 20 Feb 2026 09:52:43 +0000

Runway ML

Overview

Aspect	Details
API Base	`https://api.dev.runwayml.com/v1`
Auth	`Authorization: Bearer $RUNWAYML_API_SECRET`
Version Header	`X-Runway-Version: 2024-11-06` (required)
Task Model	Async: submit → get task ID → poll `GET /tasks/{id}` until done
Docs	https://docs.dev.runwayml.com/
API Key	https://docs.dev.runwayml.com/guides/setup

Endpoints

Text-to-Video

Endpoint: POST /v1/text_to_video
Models: gen4.5, veo3.1, veo3.1_fast, veo3
Note: gen4_turbo is not supported for text-to-video

Image-to-Video

Endpoint: POST /v1/image_to_video
Models: gen4.5, gen4_turbo, veo3.1, gen3a_turbo, veo3.1_fast, veo3
Input: promptImage (HTTPS URL, Runway URI, or data URI), promptText, ratio, duration

Models

gen4.5

Modes: Text-to-video, Image-to-video
Duration: 2–10 seconds
Ratios: 1280:720, 720:1280, 1104:832, 960:960, 832:1104, 1584:672
Notes: Flagship model; omit promptImage for text-only

gen4_turbo

Modes: Image-to-video only
Duration: 2–10 seconds
Notes: Faster than gen4.5; requires an input image

veo3.1

Modes: Text-to-video, Image-to-video
Duration: 2–10 seconds
Ratios: 1280:720, 720:1280
Notes: Google Veo 3.1–based model

veo3.1_fast

Modes: Text-to-video, Image-to-video
Notes: Faster variant of veo3.1

veo3

Modes: Text-to-video, Image-to-video
Notes: Base Veo 3 model

gen3a_turbo

Modes: Image-to-video only
Notes: Earlier-generation turbo model

Task Lifecycle

Submit: POST to /text_to_video or /image_to_video → returns { "id": "task-uuid" }
Poll: GET /v1/tasks/{id} every 5+ seconds
Statuses: submitted, in queue, SUCCEEDED, FAILED
Output: On SUCCEEDED, task.output[0] is the video URL (expires in 24–48 hours)

Input Formats

promptImage: HTTPS URL, runway:// URI, or data:image/...;base64,... data URI
Image limits: See https://docs.dev.runwayml.com/assets/inputs

API Parameters

API Field	Type	Example
`model`	string	gen4.5, gen4_turbo
`promptText`	string	"A serene mountain at sunrise"
`promptImage`	string	HTTPS URL, Runway URI, or data URI
`ratio`	string	1280:720
`duration`	integer	2–10

Pricing

Credits are the billing unit. 1 credit = $0.01. Credits are purchased in the developer portal; sales tax may apply.

Video Generation (credits per second)

Model	Credits/sec	$ per 5-sec video	$ per 10-sec video
gen4.5	12	$0.60	$1.20
gen4_turbo	5	$0.25	$0.50
gen4_aleph	15	$0.75	$1.50
gen3a_turbo	5	$0.25	$0.50
act_two	5	$0.25	$0.50
veo3	40	$2.00	$4.00
veo3.1 (audio)	40	$2.00	$4.00
veo3.1 (no audio)	20	$1.00	$2.00
veo3.1_fast (audio)	15	$0.75	$1.50
veo3.1_fast (no audio)	10	$0.50	$1.00

Example: A 5-second gen4_turbo video = 25 credits = $0.25.

Sources

Runway API docs: https://docs.dev.runwayml.com/
API reference: https://docs.dev.runwayml.com/api
Getting started: https://docs.dev.runwayml.com/guides/using-the-api
Pricing: https://docs.dev.runwayml.com/guides/pricing

fal.ai

Overview

Aspect	Details
Queue Base	`https://queue.fal.run`
Auth	`Authorization: Key $FAL_KEY`
Task Model	Queue: submit → poll status → GET result
Docs	https://docs.fal.ai/
API Key	https://fal.ai/dashboard/keys
Pricing	Pay-per-use; see https://fal.ai/pricing

Pricing

fal.ai bills by output (per second or per video). Pay only for computing consumed. Check fal.ai/pricing and individual model pages for current rates.

Video Models (representative; verify on fal.ai)

Model	Unit	Price	Output per $1
Wan 2.5	per second	$0.05	~20 seconds
Kling 2.5 Turbo Pro	per second	$0.07	~14 seconds
Veo 3	per second	$0.40	~3 seconds
Veo 3 Fast	per second	$0.10–$0.15	~7–10 seconds
Ovi	per video	$0.20	~5 videos
Pixverse v5.5 (5s)	per video	$0.15–$0.40	~2–6 videos

Pixverse v5.5 (by resolution): $0.15 (360p/540p), $0.20 (720p), $0.40 (1080p) for 5-second videos; audio +$0.05.

Pika (on fal.ai): ~$0.20–$0.40 per video depending on endpoint.

Minimax, Kling v1, Luma Dream Machine, Pixverse v4.5: Per-model pricing varies; check the model pages or dashboard.

GPU Compute (custom deployments)

GPU	VRAM	Price/hour	Price/second
H100	80GB	$1.89	$0.0005
H200	141GB	$2.10	$0.0006
A100	40GB	$0.99	$0.0003

Queue API Flow

Submit: POST https://queue.fal.run/{model_id} with { "input": { ... } } → request_id, status_url, response_url
Poll: GET {status_url} every 5+ seconds
Statuses: IN_PROGRESS, COMPLETED, SUCCEEDED, FAILED
Result: GET {response_url} → data.video.url

Models (Image-to-Video)

All models below are image-to-video only. fal.ai hosts multiple providers; each has different capabilities and pricing.

fal-ai/minimax-video/image-to-video

Aspect	Details
Provider	MiniMax
Input	`prompt` (string), `image_url` (URL or data URI)
Output	`video.url`
Optional	`prompt_optimizer` (boolean, default true)
Notes	Solid default for image animation; good quality/speed balance

Schema:

{
  "input": {
    "prompt": "A woman walks through Tokyo neon streets",
    "image_url": "https://... or data:image/jpeg;base64,...",
    "prompt_optimizer": true
  }
}

fal-ai/kling-video/v1/standard/image-to-video

Aspect	Details
Provider	Kling AI (Kuaishou)
Input	`prompt`, `image_url`
Notes	Kling 1.0–based; Kling 3.0 (o3) available elsewhere on fal
Alternate	`fal-ai/kling-video/o3/standard/image-to-video` (if listed)

fal-ai/luma-dream-machine/image-to-video

Aspect	Details
Provider	Luma AI
Input	`prompt`, `image_url`
Notes	Luma Dream Machine v1.5; known for photorealism

fal-ai/pika/v2.2/image-to-video

Aspect	Details
Provider	Pika Labs
Input	`prompt`, `image_url`
Resolution	Up to 1080p
Notes	Pika 2.2; supports camera movement hints (e.g. `[Pan left]`, `[Zoom in]`)
Pikaframes	Separate endpoint for multi-keyframe storyboards
Pikascenes	`fal-ai/pika/v2.2/pikascenes` for multi-reference images

fal-ai/pixverse/v4.5/image-to-video

Aspect	Details
Provider	Pixverse
Input	`prompt`, `image_url`
Notes	High-quality clips from text + image; v4.5 is a recent release

Input: image_url

fal.ai accepts:

HTTPS URL: Publicly accessible image URL
Data URI: data:image/jpeg;base64,{base64} — works for local files; large payloads may affect latency

Output Structure

Typical response shape:

{
  "data": {
    "video": {
      "url": "https://fal.media/files/.../output.mp4"
    }
  }
}

Some models may return video as a string URL directly.

Other fal.ai Video Models

Text-to-video: Ovi, Pixverse v5 (text-to-video), AnimateDiff
Vidu: Image-to-video
Kling 3.0 / O3: Newer Kling models; check fal.ai model list for current IDs

Sources

fal.ai docs: https://docs.fal.ai/
Queue API: https://docs.fal.ai/model-endpoints/queue
Synchronous API: https://docs.fal.ai/model-endpoints/synchronous-requests
Image-to-video tutorial: https://docs.fal.ai/examples/model-apis/generate-videos-from-image
Model pages: https://fal.ai/models (filter by image-to-video)

OpenClaw Infographic

Ramandeep Singh — Wed, 18 Feb 2026 05:12:58 +0000

NotedbookLLM is amazing. I summarized all about OpenClaw below just using this tool.

Create Memes Instantly—Right from Your Terminal!

Ramandeep Singh — Thu, 05 Feb 2026 09:22:57 +0000

You’ve seen those hilarious memes all over social media—but what if you could whip up your own, with custom text, in seconds? No design tools, no complicated editors, no extra websites, and—best of all—no coding required. Just your terminal. That’s it.

Sound impossible? It isn’t.

Introducing: Meme Factory powered by SKILLS!

All you need is any terminal, Skills.sh, and the Claude Code CLI.

Here’s how I did it:

Installed the Claude Code CLI.
Set up the Skills.sh tool from Vercel.
Jumped into the Claude terminal.
Ran npm i skills to install skill support.
Used the built-in find-skills (automatically installed!) to search for a meme-creation skill.
Instantly, a list of meme generator skills appeared, along with simple install commands.
Selected and installed the meme-factory skill.
Typed create a meme in the terminal—got an easy, guided menu to customize my meme.
Within seconds, my custom meme was generated—ready to share!

Memes, made easy and fast.

Give it a try and let the creativity flow—right from your command line!

Gold Price Monitoring real time in Powershell

Ramandeep Singh — Mon, 02 Feb 2026 07:07:07 +0000

Ever wondered if you could fetch gold prices in real time basis and view them in your local currency and weight terms.

Power of Poweshell in windows - Just PowerShell scripts enabled such monitoring systems.

Features:

Runs goldprices.ps1 in quiet mode every minute
Displays the Indian market price (with taxes)
Optional timestamp display
Customizable interval (default: 60 seconds)
Graceful Ctrl+C handling

Github link to monitor continously -
https://github.com/r123singh/ps-magic/blob/main/goldprices-monitor.ps1

Github link for ad-hoc monitor -
https://github.com/r123singh/ps-magic/blob/main/goldprices.ps1

Visit, and customize script for your local currency.

Read about Gold Price calculation here -
https://dev.to/buildandcodewithraman/gold-prices-in-india-2gkc

Gold Prices in India

Ramandeep Singh — Fri, 30 Jan 2026 17:10:40 +0000

Let’s break it down simply. At a point of time, International quoted price is $5060/oz

Theoretical price from the international quote was:

👉 ~₹14,958 / gram (pure conversion from $5060/oz @ 91.94)

But you’re seeing:

👉 ₹17,217 / gram in India

That’s a difference of roughly ₹2,260 per gram (~15%).

Here’s where that extra comes from 👇

This kind of gap is very normal for gold prices in India.

✅ 1. Import Duty (biggest factor)

India charges ~15% total import duty on gold (basic customs + agriculture cess).

That alone adds:

₹14,958 × 15% ≈ ₹2,240

You’re already almost at your observed difference just from this.

✅ 2. GST (3%)

After import duty, 3% GST is applied:

This adds another ~₹450 per gram.

(Some platforms show prices including GST, some exclude it.)

✅ 3. Premiums + logistics

On top of taxes:

Bank / bullion dealer premium
Transport + insurance
Hedging costs
Inventory risk

Usually adds ₹100–300/g.

✅ 4. Purity assumptions

International price = 24K (99.99%)

Indian listed prices may include:

24K with GST
or slightly adjusted purity benchmarks

Small but noticeable impact.

📌 In short

Your math is correct.

The jump from ₹14,958 → ₹17,217 is mainly:

🔴 Import Duty (~15%)

🔴 GST (3%)

🔴 Dealer premiums

This is why Indian gold is structurally more expensive than global spot.

Quick formula for future:

A realistic Indian gold estimate:

International INR price × 1.18 to 1.20

(18–20% covers duty + GST + premiums)

PowerShell for API Testing

Ramandeep Singh — Thu, 29 Jan 2026 08:19:28 +0000

PowerShell is a handy tool for testing REST API endpoints directly from your terminal, streamlining backend development and reducing the need to constantly switch between your terminal and browser.

Using PowerShell scripts, you can automate authentication and endpoint tests in one run. These scripts display both pass/fail statuses and response bodies for quick feedback.

The core command to make an API request is:

Invoke-RestMethod -Uri "<API_URL>" -Method Get -Headers @{Authorization = "Bearer $TOKEN"}

For a complete example script, see: https://github.com/r123singh/ps-magic

Effortless Flight Search in Your Terminal with Claude Code + MCP

Ramandeep Singh — Tue, 13 Jan 2026 07:51:44 +0000

Have you ever wished searching for flights could be as quick as typing a command—without opening a browser or wading through clunky UIs? I recently set up a super-smooth flight search right in my PowerShell terminal using Claude Code Terminal, MCP integration, and the Kiwi MCP server.

Why it’s awesome:

You only enter cities to search between—just like chatting.
It guides you interactively: select departure date, trip type, number of passengers, and cabin class with a few clicks (no extra typing).
Results are displayed in an organized, user-friendly table, with timelines and clear breakdowns.
Flights are classified by time, cost, and convenience. You can view information on stops and connecting flights.
Each option includes a direct booking link—so you can go straight to purchase with one click.
All of this happens in your terminal, in just a few moments.

What You Need

Claude Code Terminal
MCP Integration
Kiwi MCP Server

How to Set It Up

Install Claude Code Terminal:

   irm https://claude.ai/install.ps1 | iex

Set your Anthropic API key as an environment variable:

PowerShell:

 $env:ANTHROPIC_API_KEY = "your-api-key-here"

Bash:

 export ANTHROPIC_API_KEY="your-api-key-here"

Add the Kiwi.com flights MCP server:

   claude mcp add kiwi-com-flights --transport http https://mcp.kiwi.com

Start the Claude terminal:

   claude

Search for flights using a chat prompt:

   search flights from New Delhi to Washington

That’s it! You now have a streamlined, interactive flight search tool—right in your terminal.
If you travel often or value efficiency, this setup is a total game changer.