Fixing « spawn npx ENOENT » Error When Setting Up Azure DevOps MCP Server in VS Code

Publié le par
Répondre

The Problem

When trying to set up the Azure DevOps Model Context Protocol (MCP) server in VS Code, you might encounter this frustrating error:

Connection state: Error spawn npx ENOENT

This error indicates that VS Code cannot find or execute the npx command, which is needed to run the @azure-devops/mcp package.

Understanding the Root Cause

The ENOENT error (Error NO ENTry) means the system cannot locate the specified file or command. This typically happens because:

  1. Node.js/npm is not installed on your system
  2. npx is not in VS Code’s PATH environment
  3. Different Node.js versions are being used (system vs. nvm)
  4. Permission issues with the npm global packages

Solution Methods

Method 1: Verify Node.js Installation

First, check if Node.js and npm are properly installed:

node --version
npm --version
which npx

If these commands fail, install Node.js:

# Ubuntu/Debian
sudo apt update
sudo apt install nodejs npm

# Or using snap
sudo snap install node --classic

Method 2: Use Full Path to npx

If npx exists but VS Code can’t find it, use the absolute path in your mcp.json:

# Find npx location
which npx

Then update your configuration:

{
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "/usr/bin/npx",
      "args": ["-y", "@azure-devops/mcp", "${input:ado_org}"]
    }
  }
}

Method 3: Handle nvm Installations

If you’re using nvm (Node Version Manager), the path might be different:

# Check nvm path
echo $NVM_DIR
which npx

Use the nvm-specific path:

{
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "/home/username/.nvm/versions/node/v22.16.0/bin/npx",
      "args": ["-y", "@azure-devops/mcp", "${input:ado_org}"]
    }
  }
}

Method 4: Direct Node.js Execution

For maximum reliability, skip npx entirely and call Node.js directly:

# Install the package globally
npm install -g @azure-devops/mcp

# Find the package location
npm list -g @azure-devops/mcp

Then configure direct execution:

{
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "/path/to/node",
      "args": [
        "/path/to/node_modules/@azure-devops/mcp/dist/index.js",
        "${input:ado_org}"
      ]
    }
  }
}

Method 5 (FINAL WORKING SOLUTION): Simplify with Direct Organization Name

If the input prompting isn’t working, hardcode your organization name:

{
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@azure-devops/mcp", "your-org-name"]
    }
  }
}

Complete Working Configuration

Here’s a final working configuration that should handle most scenarios:

{
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@azure-devops/mcp", "your-organization"]
    }
  }
}

Troubleshooting Tips

  1. Restart VS Code after making configuration changes
  2. Check VS Code’s terminal environment – it might differ from your system terminal
  3. Install packages globally using sudo npm install -g @azure-devops/mcp
  4. Verify package installation with npm list -g @azure-devops/mcp
  5. Check permissions on npm global directories

Success Indicators

When everything works correctly, you should see:

Starting server ado
Connection state: Starting

And if the server starts but needs parameters, you’ll see:

Usage: mcp-server-azuredevops <organization_name>

This indicates the server is running but needs your Azure DevOps organization name.

Conclusion

The spawn npx ENOENT error is typically a PATH or installation issue. Start with the simplest solutions (checking Node.js installation) and progressively move to more specific fixes. The direct organization name approach is often the most reliable for production setups, while the input-based configuration offers more flexibility for multiple organizations.

Remember to replace "your-organization" with your actual Azure DevOps organization name (the part that appears in your Azure DevOps URL: https://dev.azure.com/your-organization/).

From Annoying Intern to Senior Sidekick: A Developer’s Guide to Mastering AI

Publié le par
Répondre

Let’s be honest. We’ve all been there. You paste a chunk of code into an AI chat window, type « fix this, » and hold your breath, hoping for magic. What you get back is a syntactically correct, beautifully useless piece of nonsense that completely misses the point. You sigh, close the tab, and go back to cursing at your screen and console.log()-ing your way to a solution.

The initial « wow » factor of AI in software development has quickly been replaced by a more pragmatic, and sometimes frustrating, reality. These Large Language Models (LLMs) aren’t the magical oracles we were promised. They won’t steal our jobs tomorrow, but they are changing the very nature of our work. The difference between a developer who struggles with AI and one who thrives with it comes down to a simple, fundamental shift in mindset.

Stop treating your AI like a search engine or a magic 8-ball. Start treating it like a hyper-enthusiastic, infinitely patient, but slightly amnesiac junior developer.

Once you make that switch, everything changes.

The « Vague-Posting » Fallacy: Why Your Prompts Fail

You wouldn’t walk up to a new team member, vaguely gesture at a monitor, and say, « Code something. » You’d get a blank stare, and rightfully so. Yet, this is precisely how most developers interact with AI.

A bad prompt is the developer equivalent of vague-posting on social media. It lacks context, intent, and constraints.

  • Bad Prompt: Write a Python script for an API.
  • AI’s Inner Monologue: An API for what? Using which framework? Flask? FastAPI? What should the endpoints be? What data format? Does this person even know what they want?! I’ll just give them a generic Flask « Hello, World! » and hope they go away.

To get professional-grade output, you need to provide a professional-grade brief.

The Anatomy of a Killer Prompt: Giving Your Junior AI a Proper Spec

Think of your prompt as a ticket in Jira or a project brief. It needs to be clear, concise, and contain all the necessary information for your « junior dev » to succeed. Here’s your new checklist.

1. Assign a Persona: « You Are a… »
This is the most underrated trick in the book. By giving the AI a role, you anchor its knowledge base and response style. It’s the difference between asking a random person for directions and asking a seasoned taxi driver. Use instructions files for that, even generate instructions based on your codebase (GEMINI.md, AGENT.md, copilot-instructions.md, .cursorrules, etc.).

Example: "You are a senior backend developer with 15 years of experience in .NET Core and a specialist in postgres optimization."

2. Provide Rich Context: The Lay of the Land
Your intern can’t work in a vacuum. They need the full picture. This is the most crucial part. Don’t be lazy here (it will be time more consuming if you are). Provide:

  • Relevant Code: The specific function, class, or component you’re working on.
  • File Structure: If relevant, explain the project’s layout.
  • Dependencies & Versions: (Using .NET Core 9.x and EF Core 9.x)
  • The Goal: What business problem are you trying to solve? Why does this code need to exist?

3. Define the Objective & Constraints: The « What » and « What Not »
Be explicit about the task and, just as importantly, the boundaries.

  • The Task: "Refactor this function to improve its readability and performance."
  • The Constraints: "Do not add any new external libraries. The function must remain backward-compatible with the existing API signature. Ensure you add type hints and a clear docstring explaining the logic."

4. Show, Don’t Just Tell: The Power of Few-Shot Examples
If you want the output in a specific format, give it an example! This is called « few-shot prompting » and it’s incredibly effective.

Example: "I want you to generate unit tests. Here's an example of a test for a similar function: [Paste example test code]. Now, generate three new tests for the following function: [Paste new function code]."

5. Demand a Specific Output Format: The Deliverable
Don’t let the AI just dump a wall of text. Tell it exactly how you want the information presented.

Example: "Please provide your answer in a Markdown format. First, provide the refactored code in a .NET code block. Second, create a bulleted list explaining the key changes you made and why. Finally, provide a new set of unit tests in a separate code block."

The AI-Powered Workflow: Moving Beyond Simple Code Generation

With this robust prompting strategy, you can now integrate AI across your entire development lifecycle. It becomes less of a novelty and more of a force multiplier.

For Debugging:

  • Old Way: "My code is broken, here it is."
  • New Way: "You are an expert Typescript debugger. I'm getting a 'KeyError' on line 42 of this script. Here is the full function, the stack trace, and a sample of the JSON object that is causing the error. Explain the root cause and suggest two ways to fix it, one being a simple hotfix and the other being a more robust, long-term solution."

For Refactoring and Code Reviews:

  • Old Way: "Make this better."
  • New Way: "Act as a senior software architect conducting a code review. Analyze this TypeScript function for potential performance bottlenecks, anti-patterns, and opportunities to use more modern ES6+ features. Provide your feedback in a list, referencing line numbers and suggesting specific code improvements."

For Documentation and Onboarding:

  • Old Way: "Write docs for this."
  • New Way: "Generate a README.md file for this Go project. The project is a command-line tool that does [X]. Include sections for: 'What it is', 'Installation' (assuming Go 1.19+ is installed), 'Usage' with three clear command-line examples, and a 'Configuration' section explaining theconfig.yamlfile."

For Learning and Exploration:

  • Old Way: "Explain Rust's borrow checker."
  • New Way: "I'm an experienced C++ developer trying to understand Rust's borrow checker. Explain it to me using analogies related to C++ memory management, like smart pointers (unique_ptr, shared_ptr) and RAII. Provide a simple code example in both C++ and Rust to illustrate the concept of ownership."

The Human in the Loop: You’re Still the Pilot

Here’s the crucial takeaway: AI is a phenomenal co-pilot. It can handle navigation, check systems, and manage communications, freeing you up to focus on the hard stuff—like actually flying the plane.

Your value is no longer in your ability to write boilerplate code or remember the exact syntax for a LEFT JOIN. Your value is in:

  • Architectural Vision: Designing complex, scalable, and maintainable systems.
  • Critical Thinking: Knowing when a piece of AI-generated code is brilliant and when it’s dangerously naive.
  • Domain Expertise: Understanding the business logic and user needs that the code is meant to serve.
  • Prompt Engineering: The new meta-skill of effectively directing your AI partner.

The developers who will be left behind are the ones who either reject these tools entirely or use them naively. The ones who will thrive are those who master them, transforming their AI from an annoying intern into a trusted, senior-level sidekick.

So, the next time you open that chat window, take a deep breath. You’re not talking to a machine; you’re briefing your new junior. Give them the respect of a clear, detailed task, and you’ll be amazed at what they can do for you.

Resolving the « Sharing is limited on this item » Error in SharePoint Online: A Guide to the Limited-access User Permission Lockdown Mode

Publié le par
Répondre

Introduction: The Scenario

As a SharePoint administrator or consultant, you have likely encountered scenarios where a seemingly simple task becomes unexpectedly complex. A common and often frustrating example is when a user attempts to share a file or folder with a new external guest, only to be met with the following error message:

Sharing is limited on this item.You can only copy links for people with existing access, and you cannot invite anyone new.

The immediate reaction is to verify the sharing policies. You check the tenant-level settings in the SharePoint Admin Center, then the specific site collection’s settings. You confirm that sharing with « New and existing guests » is enabled. Yet, the error persists, leaving you to question what underlying mechanism is blocking this fundamental collaborative function.

This article provides a definitive solution to this specific problem, which often lies not in modern sharing policies, but in a legacy feature: the Limited-access user permission lockdown mode.

The Misleading Symptoms: Why Standard Checks Fail

Before identifying the root cause, it is essential to understand why the conventional troubleshooting path leads to a dead end in this case. An administrator would typically perform the following checks:

  1. Tenant-Level Sharing Policy: Navigating to the SharePoint Admin Center > Policies > Sharing, you confirm that the global setting for SharePoint is set to « New and existing guests » or « Anyone. »
  2. Site Collection-Level Sharing Policy: Navigating to Active Sites, selecting the problematic site, and clicking Sharing, you verify that its individual policy is also correctly set to « New and existing guests. »

When both of these settings are correctly configured, but the error remains, it is a clear indicator that a more granular or overriding setting is at play. The error message’s inability to « invite anyone new » is the critical clue.

Identifying the Root Cause: The Limited-access User Permission Lockdown Mode

The Limited-access user permission lockdown mode is a site collection feature inherited from older versions of SharePoint. Its original purpose was to enhance security in structured, non-collaborative environments (like classic publishing portals) by preventing users with « limited access » from viewing pages or application pages.

How Modern Sharing and Limited Access Work:
When a user shares a specific file or folder, SharePoint automatically grants the recipient a special permission level called « Limited Access » on the parent elements (the library, the root of the site). This permission does not allow the user to see other content but grants them the ability to « traverse » the site hierarchy to reach the specific item they have been given access to. This is fundamental to how per-item sharing operates.

The Conflict:
When the « Limited-access user permission lockdown mode » is active, it disrupts this mechanism. It effectively removes the ability for users with Limited Access permissions to navigate the site. Consequently, when SharePoint attempts to process a new external invitation, it foresees that the new guest, even after accepting the invitation, would not be able to reach the shared content due to this lockdown. The system preemptively blocks the share, resulting in the error.

The Solution: Deactivating the Lockdown Mode

Resolving the issue involves deactivating this feature for the affected site collection. This action restores the standard behavior of the « Limited Access » permission level, thereby enabling modern sharing to function as intended.

Prerequisites: You must be a Site Collection Administrator for the target site.

Step-by-Step Instructions:

  1. Navigate to the Site: Open the SharePoint site collection where you are experiencing the sharing issue.
  2. Access Site Settings:
    • Click the Settings gear icon (⚙️) in the top-right corner.
    • Select Site information, and then click View all site settings.
    • (Alternatively, if available, you can directly click Site settings from the gear menu).
  3. Navigate to Site Collection Features:
    • Under the Site Collection Administration section, click on Site collection features.
  4. Locate and Deactivate the Feature:
    • Scroll through the list of features to find « Limited-access user permission lockdown mode. »
    • If the status is « Active, » click the Deactivate button.
  5. Confirm the Deactivation: A confirmation prompt will appear. Click « Deactivate this feature » to proceed.
  6. Verification: Return to the document library or list item you were trying to share. The sharing functionality should now work as expected, allowing you to invite new external guests.

Conclusion and Best Practices

The « Limited-access user permission lockdown mode » is a powerful but legacy feature that is fundamentally incompatible with the collaborative intent of modern SharePoint sites. While it may have specific use cases in highly restricted environments, it should be deactivated by default on all modern Team Sites and Communication Sites intended for file sharing and collaboration.

By understanding the interplay between modern sharing mechanics and legacy site features, administrators can efficiently diagnose and resolve seemingly complex issues, ensuring a seamless and productive experience for their users. If you encounter the « Sharing is limited » error, and have already confirmed your primary sharing policies, checking the status of this lockdown mode should be your next critical step.

Remove the InfoPath form customization from a SharePoint list.

Publié le par
Répondre

Removing the InfoPath customization from a list after having used ‘Customize with InfoPath’ is not always easy, especially during a migration to SharePoint Subscription Edition. Indeed, this latest version no longer includes certain options/menus that allow you to revert to the default list forms for a content type.

To identify a list customized with InfoPath, you can use the following script (https://gist.github.com/jchable/6234bd200eae4109ac77717934d14ea0):

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
 
$WebAppURL="<webapp URL>"
$ReportOutput="<path to output CSV file>"
$ResultColl = @()
 
$WebsColl = Get-SPWebApplication $WebAppURL | Get-SPSite -Limit All | Get-SPWeb -Limit All
 
Foreach($Web in $WebsColl)
{
 Foreach ($List in $web.Lists | Where { 
$_.ContentTypes[0].ResourceFolder.Properties["_ipfs_infopathenabled"]})
    {
            Write-Host "InfoPath Form : $($Web.URL), $($List.Title)"
            $Result = new-object PSObject
            $Result | add-member -membertype NoteProperty -name "Site URL" -Value $web.Url
            $Result | add-member -membertype NoteProperty -name "List Name" -Value $List.Title
            $Result | add-member -membertype NoteProperty -name "List URL" -Value "$($Web.Url)/$($List.RootFolder.Url)"
            $Result | add-member -membertype NoteProperty -name "Template" -Value $list.ContentTypes[0].ResourceFolder.Properties["_ipfs_solutionName"]
            $ResultColl += $Result
    }
}

$ResultColl | Export-csv $ReportOutput -notypeinformation

Or check in SharePoint Designer to see if certain files are present:

Form customization is enabled via the _ipfs_infopathenabled property of the content type and the form URLs.

Here is a script that remove InfoPath customization from the content types of lists in a site (https://gist.github.com/jchable/26b5161dedc4bb42ab2b8bc7563e7ed0):

$web = get-spweb "<web site URL>"
  
function removeCustomInfopathListForms([String]$folderName, [Microsoft.SharePoint.SPContentType]$ct)
{
  write-host Removing custom Infopath list form on $folderName

  # Remove InfoPath customisation
  $ct.ResourceFolder.Properties["_ipfs_infopathenabled"] = "False"
  # Reset default form URL
  $ct.NewFormUrl = ""
	$ct.EditFormUrl = ""
	$ct.DisplayFormUrl = ""
  $ct.ResourceFolder.Update()     
     
	write-host "Liste:" $list.Title "  CT:" $strContentType
     
  $folder = $web.getFolder($folderName)
  write-host Delete files from folder: $folder.Name
     
  # "Delete the InfoPath Form from the server"
  for ($i = $folder.Files.count -1; $i -gt -1; $i--)
  {
       write-host deleting $folder.Files[$i].Name
       $folder.Files[$i].delete()
  }
     
  $web.dispose()
}
  
# Check content type in all lists for InfoPath forms
foreach($list in $web.Lists) { 
    foreach ($ct in $list.ContentTypes){
        if ($ct.ResourceFolder.Properties["_ipfs_infopathenabled"] -eq "True"){
            $strfolderName =$web.url + "/" + $ct.ResourceFolder.URL
            write-host "The following url is using a custom infopath list form:"  $strFolderName                               
            removeCustomInfopathListForms -folderName $strfolderName -ct $ct
        }
    }
}
$web.Dispose()

write-host "Script ended"

[MS Breakfast] Slides de ma session sur le RAG avec Azure AI Studio

Publié le par
Répondre

Dans le cadre de cette première édition des « Microsoft breakfast » (« Petit-déjeuner Microsoft ») en décembre 2023, qui a été un véritable succès (merci à tous nos partenaires et aux speakers d’exception que sont Sylver SCHORGEN et Mehdi MAHRONG) je vous avais promis mes slides … mais disons que le temps à passer, qu’il a plu ces derniers jours et que j’ai repris les entrainements de trail … bref, j’avais juste complètement zappé et mon copilot ne l’a pas fait pour moi pendant ce temps😅

Alors les voici les slides de la session « MSBreakfast – Azure OpenAI et Microsoft 365 Copilot » :

MSBreakfast-Azure-OpenAI-et-Microsoft-365-CopilotTélécharger

How to activate Bing Chat Enterprise

Publié le par
Répondre

Here we are, Bing Chat Enterprise is out ! Have a look at the official product page : Your AI-Powered Chat for Work | Bing Chat Enterprise (microsoft.com). With Edge for Business already available, Edge is placing itself as personal and professional place to browse and use Internet service.

  1. Connect to this link to accept Bing Chat Enterprise Supplemental terms : https://www.bing.com/business/bceadmin
  2. Check the box to accept terms and click on Activate in Bing chat Enterprise zone :

In case of success you will have the following message :

If you are licensed for Microsoft 365 E3, E5, Business Standard, Business Premium, or A3 or A5 for faculty, it will comes at no additional costs for your company.

Next time, you and your collegues, will open Edge, you should see a Protected label in the upper right corner that indicates Bing Enterprise is enable and you can share data and conversations with Bing Chat securely and privately.

Setup Matomo Analytics to SharePoint Online

Publié le par
Répondre

Matomo is one of the best alternative (in terms of ease of implementation and basic features, not in terms of advanced features) in Europe for GDRP compliant analytics solution 🚀.

Matomo comes in two flavours :

  • Cloud Hosting (prices here – with commercial plugins included)
  • Self-Hosted with manuel installation (open source/free of licence cost – no commercial plugins included)

Once you have your Matomo environment ready, take the train :

Prerequisites

  1. Create your website in Matomo and get your « tracking site ID »
  2. Check your account have the right permission to add a solution to your Tenant App Catalog (if you deploy to your tenant app catalog => https://docs.microsoft.com/en-us/sharepoint/use-app-catalog) or in your Site collection App Catalog (if you deploy your tracking custom action to a site collection, or on a per site collection basis => https://docs.microsoft.com/en-us/sharepoint/dev/general-development/site-collection-app-catalog)
  3. Install Pnp PowerShell by following these steps : Installing PnP PowerShell | PnP PowerShell
  4. Download the addin and the setup script zip archive here (lastest is v1.1.0 now) : Releases · Microsoft SharePoint / SPFx / Matomo Analytics · GitLab (lsonline.fr). Feel freee to modify the source to add whatever features you need (ex : custom dimensions, …).

Add and setup the Matomo SPfx custom action

  1. Open a PowerShell console prompt
  2. Connect to your tenant with : Connect-PnPOnline -Url https://<your_tenant_name>.sharepoint.com -Interactive
    • Interactive parameter is for MFA authentication. If you don’t use MFA, omit this parameter
  3. Unzip the zip archive previously downloaded in the prerequisites
  4. Execute the following command at the root of the unzipped folder : .\setup.ps1 -siteUrl https://<your-tenant_name>.sharepoint.com -trackingUrl https://matomo.mydomain.com -trackingSiteId ‘<my_tracking_site_id>’ -tenantSolutionDeployment
    • In this case, I deployed on the entire tenant (all site collections). You can omit this parameter to deploy only on a site collection.
  5. Crack your favorite webbrowser, connect to your Matomo instance, your SharePoint is already recording user actions.

Happy analytics 👍😎

How to integrate OpenAI API (Text, Codex, DALL-e, ChatGPT coming soon) in your .NET Core app in 15 minutes

Publié le par
Répondre

OpenAI API overview (from Open AI)

The OpenAI API can be applied to virtually any task that involves understanding or generating natural language or code. We offer a spectrum of models with different levels of power suitable for different tasks, as well as the ability to fine-tune your own custom models. These models can be used for everything from content generation to semantic search and classification.

To makes it a little more understandable, so with OpenAI API you can : generate and edit text, generate/edit/explain code, generate and edit images, train a model, search, classify and comapre text. Checkt the documentation here.

We will use DaVinci GPT-3 model in our app, but you can try other models :

LATEST MODELDESCRIPTIONMAX REQUESTTRAINING DATA
text-davinci-003Most capable GPT-3 model. Can do any task the other models can do, often with higher quality, longer output and better instruction-following. Also supports inserting completions within text.4,000 tokensUp to Jun 2021
text-curie-001Very capable, but faster and lower cost than Davinci.2,048 tokensUp to Oct 2019
text-babbage-001Capable of straightforward tasks, very fast, and lower cost.2,048 tokensUp to Oct 2019
text-ada-001Capable of very simple tasks, usually the fastest model in the GPT-3 series, and lowest cost.2,048 tokensUp to Oct 2019

Important : today (02/17/2023), ChatGPT API is not yet available but OpenAI indicates that it will come soon.

Phase 1 : get your secret API key

  1. Go to the OpenAI website and create a new account
  2. Signup for an OpenAI account
  3. Confirm your email address
  4. Log in to your account and navigate to the ‘View API keys’ dashboard
  5. Click on ‘Create a new secret key’

Store your API key in a secure location. You can test the API right now, but if you intend to use OpenAI API in a real workld case scanerio, check OpenAI documentation for details on usage and pricing.

 Phase 2 : create you .NET Core project to consume OpenAI API

  1. Open Visual Studio 2022
  2. Create a new .NET Core project (in my case a Web API)
  3. Install the ‘OpenAI‘ NuGet package as below :

4. In your program.cs file, just copy the following code (replace the apiKey with yours, generated in phase 1)

using OpenAI_API;
using OpenAI_API.Completions;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseHttpsRedirection();

app.MapGet("/givemesecretoftheuniverse", (string prompt) =>
{
    var apiKey = "sk-5ucaz1m00000000000000000000000000000000";
    var answer = string.Empty;

    var openAIAPI = new OpenAIAPI(apiKey);

    var completionRequest = new CompletionRequest
    {
        Prompt = prompt,
        Model = OpenAI_API.Models.Model.DavinciText,
        MaxTokens = 2000
    };

    try
    {
        var result = openAIAPI.Completions.CreateCompletionAsync(completionRequest);

        if (result != null)
        {
            foreach (var item in result.Result.Completions)
            {
                answer += item.Text;
            }
            return Results.Text("Answer of the universe : " + answer);
        }
        else
        {
            return Results.BadRequest("Not found");
        }
    }
    catch (Exception)
    {
        return Results.Problem("OpenAI API is not available or key are incorrect");
    }
});

app.Run();

5. Run your application, and open your Postman app or your favorite web browser to open the following URL : https://<your computer ip / localhost>:<your project port>/givemesecretoftheuniverse?prompt=what is the secret of the universe

6. The flow of the power of OpenAI will flow throught your screen 😁🚀🌚

More possibilities 🚀😁

As said earlier, you can use Codex, Dall-E, etc from OpenAI just by changing the Model = OpenAI_API.Models.Model statement and adapt your code consequently. Today, ChatGPT API is not yet available but OpenAI indicates that it will come soon.

You can also try this .NET library which is pretty cool as well : https://github.com/betalgo/openai

Conclusion

Integrating OpenAI APIs into your application is just as easy as creating a minimal API with .NET Core, so test it, learn it, and make our world a better one. With ChatGPT coming soon, accessible AI is becoming a reality.

Dall-E image generator directly accessible from Edge

Publié le par
Répondre

Tired of MidJourney Discord chat based image generator or to log in Open AI ? This week, Microsoft discretly adds a shortcut in Edge to bring image generation directly to Edge users in the UI. To enable this feature :

  1. Get the lastest version of Edge
  2. Click on the + button in the right side panel
  3. Check the ‘Image creator’

4. Connect your to Microsoft account :

5. Play with Dall-E (25 credits) without quitting Edge :

You’ll be able to get your creation history by clicking on the ‘My creations’ tab. Happy image generation 🚀

Développer sous VS Code / Windows en remote sur un Linux WSL / Github Codespaces en quelques minutes

Publié le par
Répondre

Grand fan de WSL (sous-système Linux) qui apporte à Windows la touche manquante comparé à un environnement de développement Mac : un véritable Shell Linux/Unix. WSL rend accessible bon nombre d’outils de développement uniquement disponible sous Linux (ou s’exécutant mieux et avec moins de configuration et de dépendances).

A cela s’ajoute le fait que vous pouvez avoir plusieurs sous-systèmes Linux et vous en servir comme environnement de développement dédié, et cela sans avoir besoin de lancer une VM Hyper-V coûteuse en ressources et une intégration avec Windows beaucoup moindre (accès aux fichiers directement, intégration Visual Studio, etc). Pas besoin donc de déployer tous les runtimes et langages (Python, Ruby, Go, NodeJS, etc) sur votre machine de production Windows.

Cet article vous présente le développement avec un environnement distant WSL, mais cela s’applique à bon nombre d’autres scénarios dont le service Github Codespaces.

Prérequis

  • Windows Terminal : la fine fleur du terminal sous Windows (même si Commander a encore un peu d’avance mais Terminal suffit largement dans la majorité des scénario)
  • WSL installé (Windows 10/11) : voir la documentation suivante et avec une distribution déployée
  • Extensions Visual Studio Code :
    • Remote – WSL

Installation de VS Code Server sur vos distro WSL

En une ligne : dans votre shell Terminal connecté à votre système WSL, saisissez : 

code

Laissez le système installer le serveur (hôte) tout seul :

Puis laissez VS Code s’ouvrir pour vous tout seul :

En prime vous aurez droit d’avoir un walkthroughs « Get started with Remote -WSl » à vous mettre sous la dent pendant quelques minutes pour vous aider dans vos premiers pas à bien comprendre le développement remote sur votre distro Linux.

Vous pourrez aussi ouvrir directement le répertoire courant dans lequel vous avez lancer code grâce à l’explorateur :

Le terminal VS Code est déjà directement branché sur votre shell WSL :

Vous pouvez maintenant installer tous les langages et les extensions nécessaires pour faire de votre WSL votre environnement de développement.

Extensions

Les extensions de votre VS Code ne seront pas activées dans cette configuration de travail à distance sur votre instance WSL. En réalité, ils n’ont pas les droits pour accéder aux fichiers distants ni d’exécuter des scripts à distance. C’est pour cela qu’il existe des extensions de « lieu de travail » – on utilisera workspace pour la suite 🙄 – qui eux s’exécutent dans l’environnement distant et peuvent donc accéder aux fichiers, permettre de débugger, exécuter des scripts, etc. (voir schéma dans la partie suivante pour mieux comprendre l’architecture).

Il faudra les réinstaller dans l’hôte de travail à distance WSL :

Attention : soyez patient il faudra parfois un peu de temps pour que l’extension s’installe et que l’UI de VS Code réagisse pour vous dire que c’est en cours ou installé.

Optionnel : comment ça marche techniquement ?

Je ne ferais pas mieux que la documentation qui vous présente cela très bien : Supporting Remote Development and GitHub Codespaces | Visual Studio Code Extension API

Bonne lecture pour les plus techniques d’entre vous.

Conclusion

Que dire à part : à vous les joies d’un environnement de développement Linux tout en restant sur votre Windows pour utiliser le meilleur de ces deux mondes !

Vous pourrez trouver quelques informations supplémentaires spécifiques à l’utilisation d’un environnement distant WSL dans la documentation Developing in the Windows Subsystem for Linux with Visual Studio Code.