DEV Community: TheCodeStreet

Claude Code for Free in VS Code: No Login, No API Key (Ollama + Qwen 3.8)

TheCodeStreet — Mon, 02 Nov 2026 06:05:49 +0000

Last time I ran Claude Code for free in the terminal. A lot of you asked the obvious follow-up: can I do this inside VS Code?

Yes. The official Claude Code extension can skip the Claude login entirely and talk to a model running on your own PC. No API key, no subscription, no bill. Then I gave it one prompt and it built a full Space Shooter game.

How it works

The extension normally sends your prompts to Anthropic's cloud. We point it at Ollama instead, which runs Qwen 3.8 locally on localhost:11434.

Piece	Job
VS Code + Claude Code extension	The editor and the agent you chat with
Ollama	Runs the model and serves it on port `11434`
Qwen 3.8 (27B)	Actually writes the code

How you use Claude Code doesn't change. Only where the model runs does.

Before you start

VS Code (any recent version)
~32 GB of memory between RAM and VRAM
~20 GB free disk (the model is ~18 GB)
A GPU helps a lot (24 GB VRAM is ideal). Without one it still runs, just slower. ## 1. Install Ollama and pull the model

Windows: grab the installer from ollama.com. macOS / Linux:

curl -fsSL https://ollama.com/install.sh | sh
ollama --version   # needs 0.15 or newer
ollama pull qwen3.8:27b

Quick sanity check: ollama run qwen3.8:27b, say hi, then /bye.

2. Install the extension

Ctrl + Shift + X → search Claude Code → make sure the publisher is Anthropic → Install.

3. Set four environment variables (this skips the login)

Open Settings (Ctrl + ,), search Claude Code: Environment Variables, click Edit in settings.json and add:

[
  { "name": "ANTHROPIC_AUTH_TOKEN", "value": "ollama" },
  { "name": "ANTHROPIC_API_KEY",    "value": "ollama" },
  { "name": "ANTHROPIC_BASE_URL",   "value": "http://localhost:11434" },
  { "name": "ANTHROPIC_MODEL",      "value": "qwen3.8:27b" }
]

The two keys are placeholders. Ollama ignores them, but their presence stops the extension asking you to sign in. ANTHROPIC_BASE_URL is the real trick: it sends everything to your machine instead of the cloud.

Save, then Ctrl + Shift + P → Developer: Reload Window.

4. Map every model to Qwen with settings.local.json

The env vars configure the extension. This file configures your project, so nothing ever reaches for a paid model. Create .claude/settings.local.json in your project:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://127.0.0.1:11434",
    "ANTHROPIC_AUTH_TOKEN": "ollama",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_FABLE_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen3.8:27b",
    "CLAUDE_CODE_SUBAGENT_MODEL": "qwen3.8:27b",
    "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "65536"
  }
}

The ANTHROPIC_DEFAULT_*_MODEL lines cover every built-in model choice, and CLAUDE_CODE_SUBAGENT_MODEL covers sub-agents.

💡 The context here is 64k, so set Ollama's context length to 64k too, or it will quietly forget your files mid-task. This file is machine-specific, so keep it out of Git.

5. The test: one prompt, one game

I opened the Claude Code panel and pasted:

Build a complete, visually stunning Space Shooter game in a single HTML file
using HTML, CSS, and JavaScript. Use Canvas for smooth gameplay, neon space
visuals, animated stars, player movement, shooting, enemy waves, particle
explosions, power-ups, score, lives, increasing difficulty, a boss fight,
and a game-over/restart screen. Make it responsive, polished, and fun to play
with keyboard controls. Keep all code in one index.html file with no external
libraries. Ensure everything works correctly.

A few minutes later: animated stars, a ship that moves and shoots, enemy waves, explosions and a boss with its own health bar. All of it generated locally, no tokens counted. (Gameplay is in the video above.)

The honest part

It's slower and less sharp than the hosted Claude models. But for side projects, learning and prototypes, a complete working game for $0 is hard to argue with.

Quick fixes if you get stuck:

Still asks you to log in: re-check all four env vars, save, reload the window.
Connection refused: Ollama isn't running. Open the app or run ollama serve.
Model not found: the name must match qwen3.8:27b exactly in both files.

- Slow or forgetful: set Ollama's context to 64k, close GPU-heavy apps, make sure the model fits in VRAM.

Full guide with requirements, a variable-by-variable breakdown and an FAQ is on my blog: Claude Code For Free in VS Code: Full Setup Guide.

Prefer the terminal? I covered that setup here: I Run Claude Code for $0 with Ollama + Qwen 3.8.

Which local model are you using for coding right now? And what should I make it build next? 👇

Claude Code For Free: Local Setup with Ollama + Qwen 3.8

TheCodeStreet — Thu, 29 Oct 2026 08:52:54 +0000

I love Claude Code. I don't love watching the usage meter while I experiment.

So I tried running it against a local model instead. It works, it costs nothing, and the setup is shorter than this intro. Here's the TL;DR version.

The idea in one line

Claude Code can talk to any Anthropic-compatible endpoint. Ollama (0.15+) exposes one locally, so you swap the cloud model for Qwen 3.8 running on your own GPU.

Before you start

~32 GB of memory between RAM and VRAM (the 27B model is ~18 GB)
~20 GB free disk
A GPU helps a lot. Without one it runs, just slowly. ## 1. Install the two tools

# Claude Code (macOS / Linux / WSL)
curl -fsSL https://claude.ai/install.sh | bash

# Ollama (macOS / Linux). On Windows, grab the installer from ollama.com
curl -fsSL https://ollama.com/install.sh | sh

ollama --version   # needs 0.15 or newer

Windows users can install Claude Code from PowerShell with irm https://claude.ai/install.ps1 | iex.

2. Run the one command

ollama launch claude --model qwen3.8:27b

That's the whole trick. Ollama starts Claude Code wired to the local model. If you'd rather download first, run ollama pull qwen3.8:27b before it.

3. (Optional) Make it the default for a project

If you want plain claude to always use Qwen in a repo, drop this in .claude/settings.local.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://127.0.0.1:11434",
    "ANTHROPIC_AUTH_TOKEN": "ollama",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_FABLE_MODEL": "qwen3.8:27b",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen3.8:27b",
    "CLAUDE_CODE_SUBAGENT_MODEL": "qwen3.8:27b",
    "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "65536"
  }
}

Two things worth knowing:

The auth token is required but ignored, and the empty API key stops a real key from being picked up.
Bump Ollama's context length to 64k so it matches 65536. Otherwise Claude Code loses track of your files mid-task. Keep this file out of Git. It's machine-specific.

Does it actually build things?

I gave it one prompt:

Create a simple Snake game in a single index.html file
using HTML, CSS, and vanilla JavaScript.
Use a neon cyberpunk design, arrow-key controls, score tracking,
collision detection, and a restart button.
No external libraries or files.
Save the complete, working code to index.html.

It produced a working game first try: neon styling, arrow keys, score, collisions, restart. All on my machine.

The honest part

It's slower and less sharp than the hosted Claude models. For side projects, learning, and quick throwaway builds, though, I'm not going back to paying for every experiment.

Quick fixes if you get stuck:

command not found: start Ollama, then open a new terminal.
Model won't load: try a smaller Qwen size.

- Slow or forgetful: close GPU-heavy apps and raise the context length.

Full step-by-step guide (with troubleshooting and FAQ) is on my blog: Claude Code For Free: Local Setup with Ollama + Qwen 3.8.

Next up: the same free setup inside VS Code. Have you tried running coding agents on local models? What's your go-to model? 👇

How to Use Claude Code with Opus 5.5 & Fable 5.1 for Free ( No Card Required)

TheCodeStreet — Mon, 26 Oct 2026 10:26:54 +0000

Want to use Claude Code with top models like Claude Opus 5.5 and Fable 5.1, but don't want to pay for a subscription or fund an API account yet?

In this guide, I'll show you how to connect Claude Code to a third-party AI gateway that gives you 500,000 free tokens every month, with no credit card required. The setup takes about five minutes.

⚠️ Before you start: This uses a third-party service that is not affiliated with or endorsed by Anthropic. Free plan limits, available models, and pricing can change at any time. Read the disclaimer at the end before you use it for anything serious.

🎥 Watch the Video Tutorial

Prefer watching? Here's the full step-by-step walkthrough:

What You Get

Feature	Details
Free tokens	500,000 per month
Credit card	Not required
Models	Claude Opus 5.5, Fable 5.1, and more
Works with	Claude Code (via third-party inference)
Best for	Learning, side projects, prototyping

How much is 500K tokens?

A token is a small chunk of text, often part of a word. A common rule of thumb for English:

1 token ≈ 4 characters ≈ ¾ of a word
1,000 tokens ≈ 750 words
500,000 tokens ≈ 375,000 words Input and output both count. Coding sessions also send file contents and conversation history as context, so a long agentic session uses more than you might expect. Still, 500K a month is plenty for learning and for several small projects.

Why Use Claude Code with Free Tokens?

Students and beginners can learn AI-assisted coding at zero cost.
Indie developers can prototype ideas without upfront spend.
Curious developers can try premium models like Opus 5.5 before committing to a paid plan.
Content creators and educators can demo Claude Code without burning a personal budget.

Prerequisites
A computer running Windows, macOS, or Linux
An internet connection
A free account on the AI gateway: Radox AI
About 5 minutes

Step-by-Step Setup

Step 1: Install Claude Code

If you don't already have Claude Code installed, follow the official installation guide:

👉 Claude Code documentation

Once it's installed, open it once to make sure it launches correctly.

Step 2: Enable Developer Mode

Developer Mode unlocks the advanced configuration options, including third-party inference. That's what lets Claude Code send requests to a provider other than the default.

Open the settings.
Find and turn on Developer Mode.
Open the third-party inference configuration. > 💡 Menu names can change between versions. If you can't find an option, check the video above or the latest official docs.

Step 3: Add Your API Key and Endpoint

Sign up on Radox AI. No card is needed.
Open your dashboard and create an API key.
Copy the Gateway Base URL (endpoint) from the dashboard.
Paste both into the third-party inference settings in Claude Code.

API Key:   <your-api-key>
Endpoint:  <gateway-base-url-from-your-dashboard>

🔐 Treat your API key like a password. Never commit it to Git, paste it in public chats, or show it on screen in recordings.

Step 4: Test, Reload, and Launch

Click Test Connection and wait for a success message.
Reload and launch Claude Code.
Select Claude Opus 5.5 or Fable 5.1 as your model. You're ready to code with free tokens. 🎉

Try It: Your First Prompt

Here's a fun prompt to test the setup. It builds a complete, polished browser game in one shot:

Build a single-file HTML/CSS/JS game called "Orbit Rush". A glowing orb
circles a central star. Tap or press Space to switch between an inner and
outer orbit (with a smooth transition). Meteors fly in from the edges, so
dodge them and collect energy shards for points. Speed ramps up over time.

Visuals matter most: dark space background with parallax stars, neon glow,
a fading comet trail behind the orb, particle bursts on collecting and
crashing, a subtle screen shake on game over, and a polished title screen,
score HUD, and restart button. Add small WebAudio sound effects (no external
files) and save the high score in localStorage. Use canvas, 60fps, responsive
to any screen size, no libraries. Make it feel like a finished game.

Open the generated HTML file in your browser and play. A prompt like this is a good way to see what Opus 5.5 can do with a single request.

Tips to Make Your Free Tokens Last Longer

Every message sends context to the model, so a little care stretches your 500K much further:

Start fresh for new tasks. Use /clear when you switch to something unrelated, so old conversation history isn't re-sent.
Compact long sessions. Use /compact to summarize a long conversation and cut the context size.
Be specific. A clear, detailed prompt avoids back-and-forth that wastes tokens.
Point to the exact files. Name the files that matter instead of letting the agent explore your whole repo.
Match the model to the task. Save the most powerful models for hard problems, and use lighter ones for simple edits if your gateway offers them.
Check your usage. Keep an eye on the token counter in your gateway dashboard so you don't run out mid-project. ## Troubleshooting

Test Connection fails

Check that the API key was copied fully, with no extra spaces.
Check that the endpoint URL matches the dashboard exactly, including https://.
Make sure your free quota hasn't run out for the month. The model isn't listed
Reload Claude Code after saving the settings.
Check your gateway dashboard to see which models your plan currently includes. Responses suddenly stop
You may have hit your monthly limit. Check usage in the dashboard. ## FAQ

Is this really free?
At the time of writing, the gateway offers 500,000 tokens per month with no credit card. Free plans can change at any time, so check the current terms on the site.

Is this official from Anthropic?
No. It's a third-party gateway that Claude Code connects to through its third-party inference support. It isn't affiliated with or endorsed by Anthropic.

Can I use this for work projects?
I wouldn't recommend it for sensitive or proprietary code. Your prompts and code pass through a third-party service. For professional work, use an official plan or the official API.

What happens when I run out of tokens?
Requests will fail until your quota resets next month, or until you switch to another provider or plan.

Disclaimer

This guide is for educational purposes. The gateway used here is a third-party service, not affiliated with Anthropic. Free plan limits, model availability, and terms can change at any time without notice. Always:

Read the provider's terms and privacy policy
Keep your API key private
Avoid sending sensitive, personal, or proprietary data through third-party services ## Wrapping Up

With a few minutes of setup, you can use Claude Code with Opus 5.5 and Fable 5.1 on 500K free tokens a month. That's a great way to learn AI-assisted development, prototype ideas, and try premium models before paying for anything.

If this helped, watch the full video tutorial above and subscribe to The Code Street on YouTube for more indie dev and AI coding content.

💬 Are you using Claude Code yet? Paid plan, API, or free tokens? Tell me in the comments!

REA GitHub Tutorial: Reverse Engineer Anything with Claude Code (Full Setup + Fixes)

TheCodeStreet — Tue, 20 Oct 2026 19:28:48 +0000

REA (Reverse Engineer Anything) is the viral GitHub repo that gives AI coding agents like Claude Code the tools to look inside an installed app — without the source code. I installed it on Windows, pointed it at VS Code, and wrote down every error I hit along the way.

🎥 Prefer video? Watch the full walkthrough here: [Walkthrough]

What is REA?

REA is an MCP server plus a set of workflow instructions (a "skill") for your AI agent. Instead of guessing how an app works from screenshots, the agent can call REA's analysis tools — 207 of them in version 6.7.0 — to inspect the real files.

Think of it like a restaurant:

You are the customer — you ask a question in plain English.
Claude Code is the chef — it decides what to do.
REA is the chef's toolbox.
The app is the ingredient being inspected.

It supports JavaScript and Electron apps out of the box. Native .exe/.dll analysis needs Ghidra, IDA or Hopper installed separately, and full Android APK analysis needs a Java JDK.

Hype vs reality

✅ It finds real evidence inside an app's files
✅ It explains that evidence in plain language
✅ It tells you what it couldn't figure out
❌ It is not a one-click "clone this app" button
❌ Heavily protected apps need extra tools and may still leave open questions

My favourite part: findings come with a confidence level. In my test, the Electron fuse check came back as "confidence": "observed" from the shipped artifact, with the file's SHA-256 attached as proof.

How to install REA

Prerequisite: Node.js 22.19+, 24.11+ or 26+.

Mac & Linux (guided)

npx rea-agents setup

The wizard asks which agent you use and registers REA for you.

Windows (manual — this is what worked for me)

On Windows, setup deliberately doesn't edit your agent's config, so register it yourself:

node -v
npm install -g rea-agents@6.7.0
rea doctor
claude mcp add --scope user rea -- cmd /c rea mcp

Then fully restart Claude Code and run /mcp — you should see rea · connected.

cmd /c matters on Windows: rea is a .cmd launcher that Claude Code can't start directly.

⚠️ Install only from the official repo — github.com/morluto/rea — or the npm package rea-agents. Copycat repos are a real risk with tools like this.

Demo: reverse engineering VS Code

I gave Claude Code this prompt (static analysis only — nothing launched or modified):

Use the rea MCP server to statically analyse VS Code at
%LOCALAPPDATA%\Programs\Microsoft VS Code. Do not launch or modify it.
1. inspect_pe_resources and inspect_electron_fuses on Code.exe
2. Read resources\app\product.json and list every server it talks to
3. analyze_javascript_application on resources\app and map its processes
Explain each finding in plain English.

1. What Code.exe really is

Component	Version
VS Code	1.142.0
Electron	43.7.7
Chromium	150.0.7871.250
Node.js	24.21.0
Size	238 MB, 64-bit, signed by Microsoft

The internal name? electron.exe. VS Code is a web app in a desktop wrapper.

2. Nine Electron security fuses

Fuses are on/off switches baked into the executable at build time. REA read all nine. Highlights:

On: RunAsNode, EnableNodeOptionsEnvironmentVariable, EnableNodeCliInspectArguments — VS Code needs these for its CLI and helper processes.
Off: EnableEmbeddedAsarIntegrityValidation, OnlyLoadAppFromAsar — VS Code checks its own files with checksums in product.json instead.

These are design trade-offs, not bugs — but they're exactly why Electron apps are interesting to study.

3. Who VS Code talks to

From product.json: the update server, the Extension Marketplace, a GitHub-hosted MCP server gallery, Settings Sync, an A/B experimentation service, Bing-powered settings search, a voice service, and a CDN hosting AI agent SDKs. Telemetry is on by default, with an opt-out.

4. Seven processes

Main process, workbench window, shared process, extension host, pty host (terminal), file watcher, and a newer agent host. That's why one frozen extension doesn't freeze your editor — extensions run in their own process.

Troubleshooting: every error I hit

Error	Cause	Fix
`'claude' is not recognized`	`claude.exe` is in `%USERPROFILE%\.local\bin`, which wasn't on PATH	Add that folder to your user PATH, open a new terminal
`MCP server rea already exists in user config`	Already registered	Nothing to fix — restart Claude Code
`rea` missing from `/mcp`	Not restarted, or a different session/PC	Fully close and reopen Claude Code on the same PC
`provider_unavailable`	No Ghidra/IDA/Hopper found	Install Ghidra + JDK 21, set `GHIDRA_INSTALL_DIR`, run `rea doctor`
Server won't start on Windows	Missing `cmd /c`	`claude mcp add --scope user rea -- cmd /c rea mcp`
APK analysis fails	JRE instead of JDK	Install a full Java JDK

Pro tip: when anything breaks, run rea doctor first. It's read-only and tells you exactly what's missing.

My verdict

For understanding apps — yes. What used to take hours in a disassembler took minutes, in plain English.
Not a magic clone button. It gives your agent evidence; building is still your job.
Always verify anything marked "inferred" or "unknown".

As an app developer, I'll use it to check my own release builds (what really ships in my APK), learn how good open-source apps solve a feature, and audit what the tools I install connect to.

Use it responsibly

From REA's README: it's for lawful research, education, interoperability, software preservation — and software you own or are authorized to examine. Learn from apps; don't copy paid ones.

Watch the full video: Full Detailed Video

What should I reverse engineer next? Drop it in the comments 👇

I'm Rajiv — I make videos about AI tools that actually work on The Code Street.

How to Use Qwen 3 with VS Code (FREE) | Complete Setup with Ollama

TheCodeStreet — Tue, 04 Aug 2026 17:31:59 +0000

Have you ever wanted an AI coding assistant inside VS Code without paying for GitHub Copilot or other monthly subscriptions?

The good news is—you can.

Using Qwen 3 and Ollama, you can run a powerful coding model directly on your computer and use it inside VS Code.

No API costs.

No cloud dependency.

Your code stays on your machine.

📺 Watch the Complete Video Tutorial

🎥 YouTube Video:

How to Use Qwen 3 with VS Code (FREE) | Complete Setup with Ollama

What You'll Learn

By the end of this tutorial you'll know how to:

Install Ollama
Download Qwen 3
Connect Qwen 3 with VS Code
Configure OpenCode
Generate your first AI code
Fix common setup issues
Use local AI effectively

What is Qwen 3?

Qwen 3 is Alibaba's latest family of open-source large language models.

It performs well for:

Code Generation
Debugging
Code Explanation
Refactoring
General Programming Tasks

Since it can run locally using Ollama, you don't need to rely on cloud APIs for everyday coding assistance.

What is Ollama?

Ollama lets you run Large Language Models directly on your computer.

Benefits include:

Privacy
No API Charges
Offline Support
Fast Local Responses
Easy Model Management

Step 1 — Install Ollama

Download Ollama from:

https://ollama.com

Verify installation:

ollama --version

Step 2 — Download Qwen 3

Run:

ollama pull qwen3.6:latest

Verify:

ollama list

You should now see the Qwen 3 model installed locally.

Step 4 — Connect Qwen 3 with VS Code

Configure OpenCode to use your Ollama server.

Typical endpoint:

http://localhost:11434

http://localhost:11434/v1

depending on your configuration.

Step 5 — Generate Your First Code

Instead of asking:

Build an entire React application

Start with something simple.

Example:

Create a reusable React Button component using functional components and CSS Modules.

Small prompts generally produce better results with local models.

Common Mistakes

❌ Asking for an entire application

Instead:

Break the project into smaller components.

❌ Choosing the wrong model

Use a coding-capable Qwen model whenever possible.

❌ Expecting cloud-model behavior

Local models work best when you:

Keep prompts focused
Iterate gradually
Review generated code

My Experience

After experimenting with Qwen 3, I realized that the biggest limitation wasn't the model itself—it was my prompting strategy.

Once I started building projects step by step instead of expecting an entire application in one response, the quality improved significantly.

What's Next?

This article is Part 1 of the series.

In Part 2 we'll build a complete GitHub Profile Finder using:

React
GitHub API
Qwen 3
VS Code
Ollama

…all with step-by-step prompts.

Resources

Ollama

https://ollama.com

Qwen Models

https://ollama.com/library/qwen3

VS Code

https://code.visualstudio.com/

Conclusion

Running Qwen 3 locally inside VS Code is a great option if you want a private, free AI coding assistant.

Whether you're learning React, JavaScript, or working on professional software projects, local AI models have become capable enough to be part of your daily development workflow.

🎥 Prefer Watching?

If you found this article helpful, consider following TheCodeStreet for more tutorials on:

AI
.NET
C#
Ollama
Qwen
AI Agents
Semantic Kernel
VS Code
Software Development

Happy Coding! 🚀

🚨 BREAKING: Microsoft Pauses GitHub Copilot Subscriptions — What Developers Need to Know

TheCodeStreet — Fri, 24 Apr 2026 04:43:31 +0000

GitHub Copilot has become a daily coding companion for many of us…
And suddenly, new subscriptions are paused.

If you’re using AI tools for coding, this update might have surprised you.

👉 Microsoft has paused new GitHub Copilot subscriptions.

Yes — the tool many developers rely on daily just hit an unexpected pause.

But the real question is: Why? And what does this mean for us?

🎥 Watch Full Breakdown (Quick Video)

Before we dive deep, I’ve explained everything in this video:

👉 https://youtu.be/YvtdyQfV8p4

🤯 What Happened?

Microsoft has temporarily paused new GitHub Copilot subscriptions, creating confusion across the developer community.

Existing users? ✅ Still active
New subscriptions? ❌ Currently paused

This is not a shutdown — but definitely something worth paying attention to.

🧠 Why Did Microsoft Do This? (Possible Reasons)

While there’s no single official reason publicly confirmed in detail, here are some strong possibilities:

1️⃣ Infrastructure & Scaling Challenges

AI coding tools like Copilot require massive compute power.

👉 Sudden demand spikes can force companies to pause onboarding.

2️⃣ Strategic Shift in AI Offerings

Microsoft is heavily investing in AI across products like:

Azure AI
Developer tools
Enterprise AI solutions

👉 This pause could be part of a bigger product restructuring.

3️⃣ Pricing / Model Changes Incoming

We’ve seen this pattern before in AI tools.

👉 Pause → Update → Relaunch with new pricing/features

4️⃣ Quality & Performance Optimization

Microsoft might be improving:

Response quality
Latency
Model upgrades

👉 Better experience before scaling further.

👨‍💻 What This Means for Developers

This impacts different groups differently:

🔹 Existing Users

No major impact (for now)

👉 You can continue using Copilot normally

🔹 New Users

You might not be able to subscribe immediately

👉 Need to wait for updates

🔹 Teams & Organizations

Could affect onboarding new developers into AI workflows

⚡ Should You Be Worried?

Short answer: No — but stay aware.

This is likely a temporary pause, not a permanent shutdown.

But it does highlight one important thing 👇

👉 Don’t depend on a single AI tool

🔄 Alternatives You Can Explore

While Copilot is paused for new users, you can try:

ChatGPT for coding assistance
Open-source AI coding tools
IDE-integrated AI plugins

👉 Having multiple tools = better flexibility

💭 My Take

This feels less like a problem… and more like a transition phase.

We’re moving toward:

More powerful AI tools
Better integrations
Possibly new pricing models

👉 The AI coding space is evolving FAST.

🚀 Final Thoughts

If you're a developer in 2026:

👉 AI is no longer optional

👉 It’s becoming a core part of development

And moves like this from Microsoft signal something bigger coming.

👇 Let’s Discuss

What do you think?

Is this just a temporary pause?
Or a sign of a bigger shift in AI tools?

Drop your thoughts below 👇

🔗 Stay Updated

🎥 Subscribe to my channel:

https://youtube.com/@TheCodeStreet

📌 Follow me for more content on:

AI • .NET • Azure • Developer Tools • Real-world Projects

🏷️ Tags

github copilot ai programming webdev

Why DevUI Is a Game Changer for .NET Developers? Microsoft Agent Framework DevUI Demo.

TheCodeStreet — Fri, 06 Feb 2026 14:51:24 +0000

Introduction

Building and testing AI agents shouldn't require building a complex user interface from scratch. That's where DevUI comes in - a powerful development tool that's part of the Microsoft Agent Framework for .NET 10.

In this comprehensive guide, you'll learn how to set up, configure, and test multiple AI agents with different personas using a simple web interface.

Whether you're building chatbots, AI assistants, or conversational applications, DevUI provides an intuitive playground similar to Swagger UI but designed specifically for AI agents.

Watch the video tutorial above for a complete walkthrough, or continue reading for the step-by-step guide.

What is DevUI?

DevUI is a development interface included with the Microsoft Agent Framework that enables developers to:

Test AI agents in real-time during development
Manage conversations with multiple agents simultaneously
Debug agent responses without building a production UI
Prototype quickly before implementing custom interfaces
Validate system prompts and agent behavior instantly

Think of DevUI as your AI agent playground - a tool that accelerates development by providing immediate visual feedback on your agents' behavior and responses.

Key Benefits

Zero UI Code Required: Test agents immediately without building React, Angular, or Blazor interfaces
Multi-Agent Support: Switch between different agents in the same session
Conversation History: Built-in conversation management and history tracking
Development-Only: Easily disable for production deployments
OpenAI Compatible: Works with any OpenAI-compatible endpoint including Azure OpenAI, GitHub Models, and more

Prerequisites

Before we begin, ensure you have:

.NET 10 SDK installed (Download here)
Visual Studio 2026 or VS Code with C# extensions
Basic knowledge of ASP.NET Core
API access to an OpenAI-compatible service (OpenAI, Azure OpenAI, GitHub Models, etc.)
API Key for your chosen AI service (you can use GitHub Copilot)

Required NuGet Packages

For this tutorial, you'll need the following packages:

dotnet add package Microsoft.Agents.AI.DevUI
dotnet add package Microsoft.Agents.AI.Hosting
dotnet add package Microsoft.Extensions.AI
dotnet add package OpenAI

Package Overview

Package	Purpose
`Microsoft.Agents.AI.DevUI`	Provides the DevUI web interface
`Microsoft.Agents.AI.Hosting`	Agent hosting infrastructure and registration
`Microsoft.Extensions.AI`	Core AI abstractions and interfaces
`OpenAI`	OpenAI SDK for connecting to AI models

Project Setup

Let's create a new ASP.NET Core application:

dotnet new web -n DevUIDemo
cd DevUIDemo

Add the required packages as shown above, and we're ready to start coding!

Implementation Guide

Step 1: Configure the ChatClient

Open Program.cs and set up your application builder and chat client:

using Microsoft.Agents.AI.DevUI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

// Configure ChatClient with your AI service
IChatClient chatClient = new ChatClient(
    "gpt-4o",  // Model name
    new ApiKeyCredential(Environment.GetEnvironmentVariable("OPENAI_API_KEY")!), 
    new OpenAIClientOptions() { 
        Endpoint = new Uri("https://models.github.ai/inference") 
    }
).AsIChatClient();

?? Security Best Practice: Always use environment variables or secure configuration for API keys. Never hardcode credentials in your source code!

Step 2: Register Required Services

Add the necessary services to your dependency injection container:

// Register the chat client for agent use
builder.Services.AddChatClient(chatClient);

// Register OpenAI response handling
builder.Services.AddOpenAIResponses();

// Register conversation state management
builder.Services.AddOpenAIConversations();

These services provide:

AddChatClient: Registers the chat client for dependency injection
AddOpenAIResponses: Handles OpenAI API response processing
AddOpenAIConversations: Manages conversation state and history

Step 3: Create AI Agents

Now comes the fun part - creating your AI agents! The framework makes this incredibly simple:

// Create a Comic Book Guy agent from The Simpsons
builder.AddAIAgent(
    "Comic Book Guy", 
    "You are Comic Book Guy from The Simpsons. Respond with his characteristic " +
    "condescending tone, vast knowledge of pop culture, and frequent use of phrases " +
    "like 'Worst [blank] ever!' Be pedantic and superior in your responses."
);

// Create a YouTube channel advisor agent
builder.AddAIAgent(
    "CodeStreet Agent", 
    "You are an experienced YouTube content strategist specializing in tech channels. " +
    "Provide actionable advice on content ideas, SEO, thumbnails, audience engagement, " +
    "and growth strategies for programming and technology channels."
);

** Pro Tip**: Your system prompt is crucial! Be specific about the agent's personality, knowledge domain, and response style for best results.

Step 4: Configure Endpoints and Run

Finally, build the app and register the DevUI endpoints:

WebApplication app = builder.Build();

// Register OpenAI API endpoints (required for DevUI)
app.MapOpenAIResponses();
app.MapOpenAIConversations();

// Register DevUI endpoint
app.MapDevUI();

app.Run();

Complete Code Example

Here's the complete Program.cs:

using Microsoft.Agents.AI.DevUI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

IChatClient chatClient = new ChatClient(
    "gpt-4o", 
    new ApiKeyCredential(Environment.GetEnvironmentVariable("OPENAI_API_KEY")!), 
    new OpenAIClientOptions() { 
        Endpoint = new Uri("https://models.github.ai/inference") 
    }
).AsIChatClient();

builder.Services.AddChatClient(chatClient);
builder.Services.AddOpenAIResponses();
builder.Services.AddOpenAIConversations();

builder.AddAIAgent("Comic Book Guy", 
    "You are comic-book guy from The Simpsons");

builder.AddAIAgent("CodeStreet Agent", 
    "You are an agent who gives suggestions for youtube channels");

WebApplication app = builder.Build();
app.MapOpenAIResponses();
app.MapOpenAIConversations();
app.MapDevUI();
app.Run();

Running Your Application

Start the Application

Run your application using:

dotnet run

Or press F5 in Visual Studio.

Access DevUI

Once the application starts, navigate to:

http://localhost:[PORT]/devui

Replace [PORT] with the port number shown in your console output (typically 5000 or 5173).

Testing Your Agents

Select an Agent: On the left sidebar, you'll see both agents listed
Start a Conversation: Click on an agent to begin chatting
Send Messages: Type your message in the input box
View Responses: Watch your agent respond in character
Switch Agents: Click another agent to test different personas
View History: All conversation history is maintained automatically

Resources and Next Steps

Official Documentation

Further Learning

Advanced Agent Patterns: Explore multi-agent conversations and orchestration
Function Calling: Enable agents to interact with external systems
Custom UI Development: Build production interfaces using React or Blazor
Azure Deployment: Deploy agents to Azure App Service or Container Apps

Sample Code Repository

Find the complete source code for this tutorial: Source Code

Conclusion

DevUI provides a powerful, efficient way to develop and test AI agents in .NET 10 without the overhead of building custom interfaces. By following this guide, you've learned:

How to set up the Microsoft Agent Framework
Configure OpenAI-compatible chat clients
Create multiple AI agents with distinct personas
Use DevUI for rapid testing and iteration
Implement best practices for security and deployment
Troubleshoot common issues

The Microsoft Agent Framework, combined with DevUI, dramatically reduces the time from concept to functional AI agents. Whether you're building chatbots, virtual assistants, or complex multi-agent systems, these tools provide the foundation for rapid, efficient development.

Support me!

If you found this guide helpful, make sure to check out the accompanying YouTube video tutorial where I walk you through the process visually. Don’t forget to subscribe to my channel for more amazing tutorials!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

Run Large Language Models Locally in Docker | How to Use Qwen 3 with .NET Semantic Kernel?

TheCodeStreet — Fri, 19 Sep 2025 17:41:39 +0000

AI development is moving fast — but one thing that still slows developers down is relying on cloud APIs.

What if you could run powerful LLMs (Large Language Models) locally, just like spinning up a Docker container?

In this blog, I’ll show you how to:

Run LLMs locally using Docker’s Model Runner
Pull and run the Qwen 3 model
Connect it to a .NET console app with Semantic Kernel

Let’s get started! 🚀

For a more in-depth walk-through, be sure to watch my YouTube video, where I demonstrate everything step by step!

🔹 Why Run LLMs Inside Docker?

Docker is already the standard for packaging and running applications. Now, with Docker Model Runner, you can:

Pull AI models just like Docker images
Run models locally without cloud APIs
Expose OpenAI-compatible APIs to integrate seamlessly into apps

This means you can test, prototype, and even deploy AI workloads locally — cost-free and private.

🔹 Step 1: Enable Docker Model Runner

Open Docker Desktop → Settings → AI Features and enable:

✅ Docker Model Runner
✅ Host-side TCP support (on port 12434)

This allows models to expose REST APIs you can call from your apps.

🔹 Step 2: Pull and Run Qwen 3 Model

Open your terminal and run:

# Pull the model
docker model pull qwen/qwen-3b

# Run the model
docker model run qwen/qwen-3b

You’ll see an interactive chat session where you can ask questions.

Example:

> Hello
< Hi! How can I assist you today?

🔹 Step 3: Use REST API

The model exposes endpoints on:

http://localhost:12434/v1

For example, to list available models:

curl http://localhost:12434/models

You’ll see details of Qwen 3 and any other models you’ve pulled.

🔹 Step 4: Connect with Semantic Kernel (.NET)

The best part is — you don’t need to rewrite your app.

Semantic Kernel already works with OpenAI APIs, and since Docker exposes the same structure, all you do is change the base URL.

Install packages

dotnet add package Microsoft.SemanticKernel

Create a Console App

using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(
    modelId: "qwen/qwen-3b",
    apiKey: "dummy", // not required for local
    endpoint: new Uri("http://localhost:12434/v1") // Docker endpoint
);

var kernel = builder.Build();

var result = await kernel.InvokePromptAsync("Explain Docker in simple terms.");
Console.WriteLine(result);

That’s it! Your .NET app is now talking to Qwen 3 inside Docker, through Semantic Kernel.

🔹 Why This Matters

🖥️ Local-first AI → Run LLMs without internet or billing
🔒 Privacy → Your data never leaves your machine
⚡ Developer-friendly → Same SDKs, same APIs, just a different base URL
🔗 Drop-in replacement → Move between local and cloud seamlessly

✅ Final Thoughts

Running AI models is now as easy as running containers.

With Docker Model Runner, you can:

Pull Qwen 3
Run it locally
Connect it to .NET apps with Semantic Kernel

This opens up endless possibilities for building intelligent apps without cloud dependencies.

👉 What model are you planning to run first with Docker?

Drop a comment — I’d love to know!

How to Build Your First AI Agent with Semantic Kernel & DeepSeek R1 Locally with Ollama

TheCodeStreet — Sat, 16 Aug 2025 02:40:49 +0000

In this post, we will create our first AI Agent using the Microsoft Agentic Framework of Semantic Kernel and DeepSeek R1, running locally on Ollama.

We’ll walk step by step through setting up a Semantic Kernel agent that leverages DeepSeek R1 via Ollama, showing you how to install the tools, configure the model locally, and connect everything together. By the end, you’ll have a working AI YouTube Title Generator agent running entirely on your machine locally—no cloud subscription required.

What You Will Learn

How to Get Started with DeepSeek R1
How to Use Ollama for running local models
How to install and start running the DeepSeek R1 model
How to Use Semantic Kernel in C#

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

Ollama is a platform or tool (specific details may vary depending on the context) that allows users to interact with large language models (LLMs) locally. It simplifies the process of deploying and running LLMs like LLaMA, Phi, DeepSeek R1, or other open-source models.

To install Ollama, visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models have comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the command below.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify that the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.61.0" />
  <PackageReference Include="Microsoft.SemanticKernel.Agents.Core" Version="1.61.0" />
  <PackageReference Include="Microsoft.SemanticKernel.Connectors.Ollama" Version="1.61.0-alpha" />
</ItemGroup>

6. Complete code

Program.cs:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b",
    new HttpClient
    {
        BaseAddress = new Uri("http://localhost:11434"),

    });

Kernel kernel = builder.Build();

Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Welcome to TheCodeStreet - AI YouTube Title Generator!");
Console.WriteLine("------------------------------------------------------");
Console.ResetColor();
Console.WriteLine("Provide the keyword to generate title:");
string keyword = Console.ReadLine()?? "";


string instructions = """
You are a professional YouTube content strategist and SEO expert.

🎯 Keyword or Topic: {{keyword}}

Your job is to generate 5 click-worthy and SEO-friendly YouTube video titles based on a given topic or keyword.

📌 Guidelines for Generating Titles:

-- Keep them under 70 characters if possible.
-- Include emotional triggers, power words, or numbers (e.g., “Top 5”, “You Won’t Believe…”).
-- Use strong action verbs (e.g., “Boost”, “Master”, “Avoid”, “Unlock”).
-- Make titles engaging and curiosity-driven (clickbait style but still relevant).
-- Include the keyword or topic for SEO.
-- Avoid duplicate or overly similar titles.

💡 Return only the titles in a numbered list format like:
1. Title one...
2. Title two...
3. ...
""";

 instructions = instructions
    .Replace("{{keyword}}", keyword);

ChatCompletionAgent agent =
    new()
    {
        Name = "TitleGeneratorAgent",
        Instructions = instructions,
        Kernel = kernel,
    };

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Generating titles...");
Console.WriteLine("------------------------------------------------------");
await foreach (AgentResponseItem<StreamingChatMessageContent> response
    in agent.InvokeStreamingAsync())
{
    Console.Write(response.Message.Content.Replace("**",""));
}
Console.ResetColor();
Console.ReadKey();

7. Running & Testing

Ensure Ollama is Running

-Some systems auto-run Ollama; otherwise, start it

ollama run

Run Your .NET App

-Hit F5 (or Ctrl+F5) in Visual Studio.

-Watch for console output—

Support me!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

How to Create RAG using DeepSeek R1, Ollama & Semantic Kernel .NET

TheCodeStreet — Tue, 04 Mar 2025 06:20:59 +0000

Have you ever wanted to combine your own data with AI to get instant insights? In this blog post, we’ll explore exactly how to do that by building a Retriever-Augmented Generation (RAG) application using DeepSeek R1, Ollama, and Semantic Kernel. Our example scenario is a simple expense manager that tracks daily spending and lets AI answer natural-language questions like:

"How much did I spend on coffee?"
"Which day did I spend the most money overall?"
"Which day did I spend the least money overall?"

By the end of this post, you’ll see how you can load your own data (e.g., a text file, PDF documents, or others) and perform natural language Q&A over it using these tools.

For a more in-depth walk-through, be sure to watch my YouTube video, where I demonstrate everything step by step!

What is RAG (Retriever-Augmented Generation)?

Retriever-Augmented Generation (RAG) is an approach that combines:

A Retriever: A system/component to fetch relevant documents or pieces of data from a larger collection (e.g., your expense records).
A Language Model: A large language model (LLM) that can generate natural language responses based on prompts and retrieved context.

When you ask a question, RAG retrieves relevant snippets or documents from your dataset and uses them to ground the LLM’s response. This helps the AI give more accurate and context-aware answers by focusing on information you’ve provided. Essentially, you augment the AI’s knowledge by feeding it the specific data you care about.

Use Cases of RAG

Customer Support: Quickly retrieve knowledge base articles and feed them to an LLM for on-demand issue resolution.
Content Search: Search large text corpuses and summarize or answer queries about them.
Personal Knowledge Management: Organize personal notes or expense records, and use AI to query them or generate insights.
Finance and Expense Tracking: Like in our example, store transaction history, then ask AI to identify spending patterns, daily totals, or anomalies.

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Microsoft.KernelMemory.AI.Ollama" Version="0.97.250211.1" />
<PackageReference Include="Microsoft.KernelMemory.Core" Version="0.97.250211.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

Download Complete Project

6. Source Code

using Microsoft.KernelMemory;
using Microsoft.KernelMemory.AI.Ollama;

var config = new OllamaConfig
{
    Endpoint = "http://localhost:11434",
    TextModel = new OllamaModelConfig("deepseek-r1:1.5b", 131072),
    EmbeddingModel = new OllamaModelConfig("deepseek-r1:1.5b", 2048)
};

var memory = new KernelMemoryBuilder()
    .WithOllamaTextGeneration(config)
    .WithOllamaTextEmbeddingGeneration(config)
    .Build<MemoryServerless>();

Console.WriteLine("Processing document, please wait...");

await memory.ImportDocumentAsync("expenses.txt", documentId: "DOC001");

Console.WriteLine("Model is ready to take questions\n");

while(await memory.IsDocumentReadyAsync("DOC002"))
{

    Console.WriteLine("Ask your questions\n");

    var question = Console.ReadLine();

    var answer = await memory.AskAsync(question);

    Console.WriteLine(answer.Result);

    Console.WriteLine("\n Sources:");

    foreach(var x in answer.RelevantSources)
    {
        Console.WriteLine($" {x.SourceName} - {x.SourceUrl} - {x.Link}");
    }

}

Daily expense data

Date        | Category       | Amount
------------|----------------|-------
2025-02-13  | Groceries      | 45.30
2025-02-13  | Transport      | 12.00
2025-02-14  | Coffee         | 4.50
2025-02-14  | Rent           | 800.00
2025-02-15  | Groceries      | 54.20
2025-02-16  | Entertainment  | 30.00
2025-02-16  | Transport      | 10.00
2025-02-17  | Bills          | 120.00
2025-02-17  | Coffee         | 3.75
2025-02-18  | Groceries      | 62.40

Save this info as expenses.txt, put it into the bin directory, and run the application.

Now you are good for asking some questions like:

“How much did I spend on coffee?”
“Which day did I spend the most money overall?”
“Which day did I spend the least money overall?”

The AI will use the embedded expense data to calculate or deduce answers. It should also list the sources (e.g., the document ID containing relevant info)

Support me

If you found this guide helpful, make sure to check out the accompanying YouTube video tutorial, in which I walk you through the process visually. Don’t forget to subscribe to my channel for more amazing tutorials!

I would appreciate it if you could buy me a coffee.

How to Build Blog Generator AI App Using Deep Seek R1 and Semantic Kernel in .NET9

TheCodeStreet — Thu, 06 Feb 2025 10:46:19 +0000

In this post, I’m excited to share the journey behind our latest project: building a blog generator AI app that harnesses the power of Deep Seek R1, Semantic Kernel, and .NET9. This blog serves as a companion to my YouTube video where I walk through the entire process step-by-step.

Introduction

Have you ever found yourself staring at a blank screen, struggling to come up with blog content? What if you could let AI do the heavy lifting and generate blog posts for you? In this tutorial, I'll show you how to build an AI-powered blog generator that not only speeds up content creation but also produces quality posts automatically.

What You'll Learn

Integrating Deep Seek R1: Learn how to leverage advanced search capabilities to gather relevant content and ideas.
Using Semantic Kernel: Discover how to orchestrate AI tasks for natural language processing and content generation.
Building with .NET9: See how .NET9 provides a robust framework for developing and deploying your AI application.
Step-by-Step Guidance: Follow a clear, concise guide that breaks down the process into manageable steps.

Why Build an AI-Powered Blog Generator?

Automating blog creation saves you time and effort, allowing you to focus on other aspects of your business or creative pursuits. This project not only demonstrates cutting-edge technology integration but also provides a scalable solution for content creators and developers alike.

Technologies at a Glance

Deep Seek R1: This tool helps in deep searching, ensuring your content is backed by extensive and relevant data.
Semantic Kernel: Acts as the brain behind content generation by processing natural language and orchestrating AI tasks.
.NET9: The latest iteration of .NET offers improved performance, modern features, and a great development experience for building robust applications.

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Codeblaze.SemanticKernel.Connectors.Ollama" Version="1.3.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

6. Code

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Codeblaze.SemanticKernel.Connectors.Ollama;
using Microsoft.Extensions.DependencyInjection;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b", "http://localhost:11434");

builder.Services.AddScoped<HttpClient>();

Kernel kernel = builder.Build();
var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();

string GetUserInput(string prompt)
{
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine(prompt);
    Console.ForegroundColor = ConsoleColor.White;
    return Console.ReadLine();
}

string topic = GetUserInput("Tell me the topic for the blog");
string tone = GetUserInput("Provide blog tone");
int length = Convert.ToInt32(GetUserInput("Provide total blog length"));
string keywords = GetUserInput("Provide some keywords to target");

string prompt = $@"
Your_prompt
";

var blogResponse = await kernel.InvokePromptAsync(prompt);

Console.ForegroundColor = ConsoleColor.DarkCyan;

Console.WriteLine(blogResponse.ToString());

Console.WriteLine("Press enter to exit...");
Console.ReadLine();

Downlaod Complete Project

Generated Blog

It generates the blog into markdown format, which Dev.to and Github support, you can also easily convert it into WordPress formats.

# The Future of Social Media Marketing: Why It’s Revolutionizing Modern Business Strategies  

## The Rise of Social Media in the Modern World  

In an era where social media has taken center stage as a key tool for business growth, social media marketing has emerged as a transformative force. From connecting with customers and driving sales to engaging the public on every level, this platform is reshaping how businesses approach their communication strategies.  

## The Key Benefits of Social Media Marketing  

### 1. **Sustainable Social Media Strategy**  
One of the most significant advantages of social media marketing is its ability to break free from traditional marketing boundaries. By leveraging platforms like Instagram and Facebook, businesses can consistently build relationships with customers who may not be reachable through other channels. This strategy ensures that the brand remains relevant and effective in the face of ever-changing market conditions.  

### 2. **Increased Visibility & Reach**  
Social media is renowned for its global reach. Through consistent posting and interactive content, brands gain visibility beyond their local markets. For example, a small business might see its product appear on billions of Instagram stories or Facebook posts every day, creating a loyal audience that would be difficult to compete with in a traditional marketing campaign.  

### 3. **Targeted Audience Engagement**  
One of the most powerful tools of social media marketing is its ability to target specific audiences. By analyzing data from platforms like Instagram and Facebook, businesses can identify demographics and interests where they can create more effective campaigns. This targeted approach ensures that marketing efforts align with customer needs, leading to higher engagement and conversions.  

### 4. **Building a Social Following**  
Social media is not just about sharing content; it’s also about building a community around the brand. By engaging with followers regularly and responding to comments, businesses can establish trust and credibility. This follows can lead to long-term relationships with customers who are drawn to brands that value their connection and want to share their own.  

### 5. **Improved Customer Relationships**  
Social media marketing is about more than just selling a product. It’s also about fostering meaningful connections. By sharing personal stories, tips, and updates, businesses can connect deeply with their audience and strengthen long-term relationships. This creates loyalty and trust that can translate into repeat business.  

## Examples of Social Media Marketing in Action  

### Instagram Marketing: A Global Reach  
A small tech startup, *TechGenius*, used Instagram to launch its latest product line. They created content that highlighted the benefits of their innovation, connecting with customers across countries through consistent posting and interactive posts. This strategy not only brought their product to a global audience but also built a loyal following.  

### Facebook Marketing: Building a Community  
A retail store, *FashionFlix*, used Facebook to create a community around its products. By sharing behind-the-scenes content, engaging with customers, and participating in influencer collaborations, the brand established itself as knowledgeable and trustworthy. This not only helped sell their clothing but also fostered connections that could lead to word-of-mouth referrals.  

### A/B Testing on Social Media: Measuring Success  
Social media marketing often involves testing different strategies to determine what works best for a business. By running A/B tests on platforms like Instagram or Facebook, companies can see which content types resonate with their audience and adjust their marketing efforts accordingly. This data-driven approach ensures that marketing initiatives are effective and aligned with customer needs.  

## Tools & Platforms for Social Media Marketing  

From content creation tools to analytics platforms, there’s no shortage of resources available to businesses looking to improve their social media strategy. Platforms like Instagram, Facebook, and YouTube have built into them powerful tools for creating engaging posts, tracking engagement, and measuring performance. By utilizing these features effectively, businesses can maximize the impact of their social media marketing efforts.  

## The Ultimate Guide: Tips on Social Media Marketing  

### 1. **Content Creation**  
The foundation of any successful social media strategy is well-crafted content. Businesses should focus on creating engaging, relevant, and timely posts that resonate with their audience. Whether it’s showcasing a product, sharing tips for a task or discussing recent events, the right content can catch people’s attention and encourage action.  

### 2. **Engagement**  
Social media is not just about posting; it’s also about interacting with your audience. Regular updates and timely responses to comments and questions create a sense of connection and trust. This engagement not only helps build relationships but also reinforces the brand’s message, making customers more likely to return for future purchases.  

### 3. **Analytics**  
To maximize the effectiveness of social media marketing, businesses should track their performance through analytics tools. These tools allow them to measure the impact of their content, identify trends in their audience, and adjust their strategies accordingly. By staying data-driven, they can ensure that their efforts are aligned with customer needs and driving results.  

### 4. **Leverage Influencer Marketing**  
Influencers are a powerful tool in social media marketing. Businesses should engage with influencers to gain credibility and reach a wider audience. Collaborating with influencers or following them on platforms like Instagram can help establish authority and trust, leading to more engagement from their followers.  

### 5. **Stay Updated with Trends**  
Social media is a dynamic platform that evolves quickly. To stay ahead of the curve, businesses should be aware of new trends and tools available on platforms like Instagram, Facebook, and Twitter. Keeping their strategy updated ensures they remain relevant in a competitive market and can adapt to changing customer preferences.

Support me

I would appreciate it if you could buy me a coffee.

Conclusion

Building a blog generator AI app is not only an exciting project but also a practical solution for anyone looking to enhance their content creation process. I hope this guide inspires you to explore the possibilities of AI in your projects. If you have any questions or ideas, feel free to leave a comment below!

Feel free to leave your questions, comments, or suggestions below. Happy coding!

How To Use DeepSeek With .NET 9 | Hands-On With DeepSeek R1, Semantic Kernel & C#

TheCodeStreet — Sat, 01 Feb 2025 07:40:23 +0000

In this post, we will integrate DeepSeek R1 into a .NET 9 using Semantic Kernel. If you’re looking to get started with DeepSeek models locally, this hands-on guide is for you.

What You Will Learn

How to Get Started with DeepSeek R1
How to Use Ollama for running local models
How to install and start running the DeepSeek R1 model
How to Use Semantic Kernel in C#

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Codeblaze.SemanticKernel.Connectors.Ollama" Version="1.3.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

6. Complete code

The Semantic Kernel can use a custom connector to talk to local endpoints. For simplicity, we’ll outline a sample approach:

Program.cs:

using Codeblaze.SemanticKernel.Connectors.Ollama;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b", "http://localhost:11434");

builder.Services.AddScoped<HttpClient>();
var kernel = builder.Build();

while (true)
{
    string input = "";
    Console.WriteLine("Ask anything to Deepseek");
    input = Console.ReadLine();
    var response = await kernel.InvokePromptAsync(input);
    Console.WriteLine($"\nDeepseek: {response}\n");
}

7. Running & Testing

Ensure Ollama is Running

-Some systems auto-run Ollama; otherwise, start it

ollama run

Run Your .NET App

-Hit F5 (or Ctrl+F5) in Visual Studio.

-Watch for console output—

Support me!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

DEV Community: TheCodeStreet

Claude Code for Free in VS Code: No Login, No API Key (Ollama + Qwen 3.8)

How it works

Before you start

2. Install the extension

3. Set four environment variables (this skips the login)

4. Map every model to Qwen with settings.local.json

5. The test: one prompt, one game

The honest part

- Slow or forgetful: set Ollama's context to 64k, close GPU-heavy apps, make sure the model fits in VRAM.

Claude Code For Free: Local Setup with Ollama + Qwen 3.8

The idea in one line

Before you start

2. Run the one command

3. (Optional) Make it the default for a project

Does it actually build things?

The honest part

- Slow or forgetful: close GPU-heavy apps and raise the context length.

How to Use Claude Code with Opus 5.5 & Fable 5.1 for Free ( No Card Required)

🎥 Watch the Video Tutorial

What You Get

How much is 500K tokens?

Why Use Claude Code with Free Tokens?

Prerequisites

Step-by-Step Setup

Step 1: Install Claude Code

Step 2: Enable Developer Mode

Step 3: Add Your API Key and Endpoint

Step 4: Test, Reload, and Launch

Try It: Your First Prompt

Tips to Make Your Free Tokens Last Longer

Disclaimer

REA GitHub Tutorial: Reverse Engineer Anything with Claude Code (Full Setup + Fixes)

What is REA?

Hype vs reality

How to install REA

Mac & Linux (guided)

Windows (manual — this is what worked for me)

Demo: reverse engineering VS Code

1. What Code.exe really is

2. Nine Electron security fuses

3. Who VS Code talks to

4. Seven processes

Troubleshooting: every error I hit

My verdict

Use it responsibly

How to Use Qwen 3 with VS Code (FREE) | Complete Setup with Ollama

📺 Watch the Complete Video Tutorial

What You'll Learn

What is Qwen 3?

What is Ollama?

Step 1 — Install Ollama

Step 2 — Download Qwen 3

Step 4 — Connect Qwen 3 with VS Code

Step 5 — Generate Your First Code

Common Mistakes

❌ Asking for an entire application

❌ Choosing the wrong model

❌ Expecting cloud-model behavior

My Experience

What's Next?

Resources

Ollama

Qwen Models

VS Code

Conclusion

🎥 Prefer Watching?

🚨 BREAKING: Microsoft Pauses GitHub Copilot Subscriptions — What Developers Need to Know

🎥 Watch Full Breakdown (Quick Video)

🤯 What Happened?

🧠 Why Did Microsoft Do This? (Possible Reasons)

1️⃣ Infrastructure & Scaling Challenges

2️⃣ Strategic Shift in AI Offerings

3️⃣ Pricing / Model Changes Incoming

4️⃣ Quality & Performance Optimization

👨‍💻 What This Means for Developers

🔹 Existing Users

🔹 New Users

🔹 Teams & Organizations

⚡ Should You Be Worried?