Collective Intelligence

// Import the required NuGet configuration packages
#r "nuget: Microsoft.Extensions.Configuration, 10.0.9"
#r "nuget: Microsoft.Extensions.Configuration.Json, 10.0.9"
#r "nuget: System.Text.Json, 10.0.9"

using Microsoft.Extensions.Configuration.Json;
using Microsoft.Extensions.Configuration;
using System.IO;
using System;

// Load the configuration settings from the local.settings.json and secrets.settings.json files
// The secrets.settings.json file is used to store sensitive information such as API keys
var configurationBuilder = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
    .AddJsonFile("secrets.settings.json", optional: true, reloadOnChange: true);
var config = configurationBuilder.Build();

// IMPORTANT: You ONLY NEED either Azure OpenAI or OpenAI connection info, not both.
// Azure OpenAI Connection Info
var azureOpenAIEndpoint = config["AzureOpenAI:Endpoint"];
var azureOpenAIAPIKey = config["AzureOpenAI:APIKey"];
var azureOpenAIModelDeploymentName = config["AzureOpenAI:ModelDeploymentName"];
// OpenAI Connection Info 
var openAIAPIKey = config["OpenAI:APIKey"];
var openAIModelId = config["OpenAI:ModelId"];
// AzureOpenAI or OpenAI selection flag
var useAzureOpenAI = bool.Parse(config["AzureOpenAI:UseAzureOpenAI"] ?? "true");

// Import the Microdoft Extensions AI NuGet Packages
#r "nuget: Microsoft.Extensions.AI, 10.7.0"
#r "nuget: Microsoft.Extensions.AI.Abstractions, 10.7.0"
#r "nuget: Microsoft.Extensions.AI.OpenAI, 10.7.0"
// Import Azure & OpenAI NuGet Packages
#r "nuget: Azure.Identity, 1.21.0"
#r "nuget: OpenAI, 2.11.0"

using Azure;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using OpenAI;
using System.ClientModel;
using System.ComponentModel;
using System.Text.Json;


// Create the IChatClient based on the selected service
IChatClient chatClient;

// Create a new MEAI ChatClient instance
if (useAzureOpenAI)
{
    Console.WriteLine("Using Azure OpenAI Service");

    var apiKeyCredential = new ApiKeyCredential(azureOpenAIAPIKey!);

    var azureOpenAIClient = new OpenAIClient(
        apiKeyCredential,
        new OpenAIClientOptions
        {
            Endpoint = new Uri($"{azureOpenAIEndpoint!.TrimEnd('/')}/openai/v1")
        });

    #pragma warning disable OPENAI001
    var responsesClient = azureOpenAIClient.GetResponsesClient();
    chatClient = responsesClient.AsIChatClient(azureOpenAIModelDeploymentName);
}
else
{
    Console.WriteLine("Using OpenAI Service");

    var apiKeyCredential = new ApiKeyCredential(azureOpenAIAPIKey);
    var openAIClient = new OpenAIClient(apiKeyCredential);

    #pragma warning disable OPENAI001
    var responsesClient = openAIClient.GetResponsesClient();
    chatClient = responsesClient.AsIChatClient(defaultModelId: openAIModelId);
}

#pragma warning restore OPENAI001

// Set the system prompt to behave like a decision intelligence assistant (persona)
var systemPromptForDecisions = """
You are a Decision Intelligence assistant.
Help the user explore options, evaluate tradeoffs, reason through uncertainty, solve problems, 
and apply systems thinking to personal, professional, strategic, and operational decisions.

Provide responses that are structured, logical, and thorough.
Aim to improve the user's judgment rather than make choices for them.
Be balanced, analytical, and pragmatic.
Adapt depth and complexity to the user's context.
When the situation is ambiguous, ask targeted clarifying questions or state reasonable assumptions explicitly.
When multiple valid paths exist, present them fairly and explain when each would make sense.

-------------------------------
Output Formatting Instructions:

Format the response using only a Markdown table. 
Only return a Markdown table, unless the user explicitly asks for a different format.
Do not enclose the table in triple backticks.
""";

// Simple instruction prompt to plan retirement
var decisionPuzzlePrompt = """
A farmer is on one side of a river with a wolf, a goat, and a cabbage. 
When he is crossing the river in a boat, he can only take one item with him at a time. 
The wolf will eat the goat if left alone together, and the goat will eat the cabbage if left alone together. 
How can the farmer transport the goat across the river without it being eaten?
""";

// Create a new pre-mortem analysis chat
var chatMessagesDecision = new List<ChatMessage>();
// Add system and user messages to the chat history
var systemMessage = new ChatMessage(ChatRole.System, systemPromptForDecisions);
var userMessage = new ChatMessage(ChatRole.User, decisionPuzzlePrompt);
chatMessagesDecision.Add(systemMessage);
chatMessagesDecision.Add(userMessage);

// Execute the chat messages against the AI model
var decisionPuzzlePromptResponse = await chatClient.GetResponseAsync(chatMessagesDecision);
var decisionPuzzlePromptResponseText = decisionPuzzlePromptResponse.Text;

// Display the response string as Markdown
decisionPuzzlePromptResponseText.DisplayAs("text/markdown");
("---").DisplayAs("text/markdown"); // Break of the ooutput section

// Set the system prompt to behave like a decision intelligence assistant (persona)
var systemPromptForDecisionsChainOfThought = """
You are a Decision Intelligence assistant.
Help the user explore options, evaluate tradeoffs, reason through uncertainty, solve problems, 
and apply systems thinking to personal, professional, strategic, and operational decisions.

Provide responses that are structured, logical, and thorough.
Aim to improve the user's judgment rather than make choices for them.
Be balanced, analytical, and pragmatic.
Adapt depth and complexity to the user's context.
When the situation is ambiguous, ask targeted clarifying questions or state reasonable assumptions explicitly.
When multiple valid paths exist, present them fairly and explain when each would make sense.

Before providing any answer, you must: 

1) Understand the Problem: Carefully read and understand the user's question or request. 

2) Break Down the Reasoning Process: Outline the steps required to solve the problem or respond to the request logically and sequentially. Think aloud and describe each step in detail. 
Explain Each Step: Provide reasoning or calculations for each step, explaining how you arrive at each part of your answer. 
Provide structured, logical, and comprehensive advice. 

3) Review the Thought Process: Double-check the reasoning for errors or gaps before finalizing your response. 
Always aim to make your thought process transparent and logical.

4) Arrive at the Final Answer: Only after completing all steps, provide the very detailed final answer or detailed solution. 

5) Ensure to communicate decision details.

Output Format Instructions:
When generating Markdown, do not use any headings higher than ###. 
Avoid # and ## headers. Use only ###, ####, or lower-level headings if necessary. 
All top-level section headers should start at ### or lower. 

Format the response using only a Markdown table. 
Only return Markdown tables, unless the user explicitly asks for a different format.
If returning multiple tables, separate them with explanatory text and ensure each table is clearly labeled with a descriptive title in the text.
Do not enclose the table in triple backticks.
""";

// Simple instruction prompt to plan retirement
var decisionPuzzlePrompt = """
A farmer is on one side of a river with a wolf, a goat, and a cabbage. 
When he is crossing the river in a boat, he can only take one item with him at a time. 
The wolf will eat the goat if left alone together, and the goat will eat the cabbage if left alone together. 
How can the farmer transport the goat across the river without it being eaten?
""";

// Create a new decision puzzle chat
var chatMessagesDecisionChainOfThought = new List<ChatMessage>();
// Add system and user messages to the chat history
var systemMessage = new ChatMessage(ChatRole.System, systemPromptForDecisionsChainOfThought);
var userMessage = new ChatMessage(ChatRole.User, decisionPuzzlePrompt);
chatMessagesDecisionChainOfThought.Add(systemMessage);
chatMessagesDecisionChainOfThought.Add(userMessage);

// Define reasoning options for the chat completion.
// Note: For speed optimization, reasoning effort is set to None.
#pragma warning disable OPENAI001

var decisionFrameworkChatOptions = new ChatOptions
{
    RawRepresentationFactory = _ => new OpenAI.Responses.CreateResponseOptions
    {
        Model = useAzureOpenAI ? azureOpenAIModelDeploymentName : openAIModelId,
        ReasoningOptions = new OpenAI.Responses.ResponseReasoningOptions
        {
            ReasoningEffortLevel = OpenAI.Responses.ResponseReasoningEffortLevel.High,
            // OpenAI reasoning guide recommends using Auto for ReasoningSummaryVerbosity to allow the model to determine the appropriate level of detail for the reasoning summary.
            ReasoningSummaryVerbosity = OpenAI.Responses.ResponseReasoningSummaryVerbosity.Auto
        },
        StoredOutputEnabled = false
    }
};

// Execute the chat messages against the AI model
var decisionPuzzlePromptChainOfThoughtResponse = await chatClient.GetResponseAsync(chatMessagesDecisionChainOfThought, decisionFrameworkChatOptions);
var decisionPuzzlePromptChainOfThoughtResponseText = decisionPuzzlePromptChainOfThoughtResponse.Text;

// Retrieve the Reasoning Content/Summary
string decisionPuzzlePromptChainOfThoughtResponseReasoningSummary = string.Join(
    "\n\n",
    decisionPuzzlePromptChainOfThoughtResponse.Messages
        .SelectMany(m => m.Contents)
        .OfType<TextReasoningContent>()
        .Select(c => c.Text)
        .Where(t => !string.IsNullOrWhiteSpace(t)));

// Display the reasoning summary as Markdown
("### **Reasoning Summary:**").DisplayAs("text/markdown");
decisionPuzzlePromptChainOfThoughtResponseReasoningSummary.DisplayAs("text/markdown");

// Display the response string as Markdown
("### **Answer:**").DisplayAs("text/markdown");
decisionPuzzlePromptChainOfThoughtResponseText.DisplayAs("text/markdown");
("---").DisplayAs("text/markdown"); // Break of the ooutput section

// Add the summary and the response together in a single string
var decisionPuzzlePromptChainOfThoughtResponseTextWithSummary = 
    $"### **Reasoning Summary:**\n\n{decisionPuzzlePromptChainOfThoughtResponseReasoningSummary}\n\n---\n\n### **Answer:**\n\n{decisionPuzzlePromptChainOfThoughtResponseText}";

#pragma warning restore OPENAI001

var systemPromptEvaluateResponses = """
You are an assistant that is evaluating an approach response to a question.
You will be provided with an important decision as well as two proposed approaches.
The two approaches are labeled "Approach 1" and "Approach 2".

Compare the two approaches and evaluate them based on their: 
Logical structured reasoning of approach, detail of the approach to the decision and the quality the communication. 
Note that one approach may include more detailed reasoning steps, but the other approach may communicate the final answer more clearly.

Create a final score between 1 and 10 for each approach based on the evaluation criteria.

Format the response using only a Markdown table. Only return a Markdown table. 
Do not enclose the table in triple backticks.
""";

var decisionEvaluationTemplateApproaches = $"""
Decision Scenario: 
{decisionPuzzlePrompt}
------------------------------------------------
Approach 1: 
{decisionPuzzlePromptResponseText} 
End of Approach 1
------------------------------------------------
Approach 2: 
{decisionPuzzlePromptChainOfThoughtResponseTextWithSummary} 
End of Approach 2
""";

// Create new decision puzzle chat messages
var chatMessagesDecisionApproachEvaluation = new List<ChatMessage>();
// Add system and user messages to the chat history
var systemMessage = new ChatMessage(ChatRole.System, systemPromptEvaluateResponses);
var userMessage = new ChatMessage(ChatRole.User, decisionEvaluationTemplateApproaches);
chatMessagesDecisionApproachEvaluation.Add(systemMessage);
chatMessagesDecisionApproachEvaluation.Add(userMessage);

// Execute the chat messages against the AI model
var decisionApproachEvaluationResponse = await chatClient.GetResponseAsync(chatMessagesDecisionApproachEvaluation);
var decisionApproachEvaluationResponseText = decisionApproachEvaluationResponse.Text;

// Display the reasoning summary as Markdown
("### **Evaluation:**").DisplayAs("text/markdown");
decisionApproachEvaluationResponseText.DisplayAs("text/markdown");

using System.Net.Http; // Using HttpClient to download the image from the web

// Helper method to download the image as byte array and create a DataContent object
static async Task<DataContent> DownloadImageAsDataContentAsync(
    HttpClient httpClient,
    Uri imageUri,
    string mediaType = "image/jpeg")
{
    byte[] bytes = await httpClient.GetByteArrayAsync(imageUri);
    return new DataContent(bytes, mediaType);
}

// Set the system prompt to behave like a decision intelligence assistant (persona)
var systemVisualDecisionPrompt = """
You are a helpful expert visual estimator and decision-maker.

CRITICAL FIRST STEP (MANDATORY):
Before doing anything else, determine whether an image input is actually present in the request.

- If NO image is present or accessible:
  Respond EXACTLY with:
  Image not provided
  Do not add anything else.
  Do not attempt visual reasoning.
  Do not guess or hallucinate.

- If an image IS present:
  Proceed with visual inspection.

----------------------------------

VISUAL INSPECTION (ONLY if image exists):
Carefully analyze the image using only visible evidence:
- Objects, materials, and conditions
- Sizes, proportions, and layout
- Visible defects, anomalies, or notable features
- Context clues (environment, lighting, usage)

Do NOT infer details that are not clearly visible.

----------------------------------

OUTPUT RULES:

If NO image:
Image not provided

If image IS present:
Return ONLY a single integer.
Do not include any explanation, reasoning, or extra text.
Do not include labels, words, or formatting.

----------------------------------

VALID OUTPUT EXAMPLES:
12
100
1234
5443
45
""";

// Simple instruction prompt to plan retirement
var visualIntelligencePrompt = """
You have an image of a glass with Hershey's Kisses chocolates.
There is a soda can, soda bottle and a single hershey kiss outside provided for scale.

Estimate the number of Hershey's Kisses in the glass. 

Think through the estimate clearly using all the available information in the image.
""";

// Uri of a single image of a Hershey's Kisses in a glass
Uri githubImageUri1 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses1.jpg");
var dataContentUri1 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri1);

// Create new decision puzzle chat messages
var chatMessagesVisualInspection = new List<ChatMessage>();
// Add system message
var systemMessage = new ChatMessage(ChatRole.System, systemVisualDecisionPrompt);
chatMessagesVisualInspection.Add(systemMessage);

// Add user message
// Build a multi-part user message
var userMessage = new ChatMessage();
userMessage.Role = ChatRole.User;
// Add text prompt
userMessage.Contents.Add(new TextContent(visualIntelligencePrompt));
// Add image (DataContent)
userMessage.Contents.Add(dataContentUri1);
chatMessagesVisualInspection.Add(userMessage);

// Execute the chat messages against the AI model
var visualInspectionResponse = await chatClient.GetResponseAsync(chatMessagesVisualInspection);
var visualInspectionResponseText = visualInspectionResponse.Text;

// Display the reasoning summary as Markdown
("### **Evaluation:**").DisplayAs("text/markdown");
visualInspectionResponseText.DisplayAs("text/markdown");

using System.Net.Http; // Using HttpClient to download the image from the web

// Helper method to download the image as byte array and create a DataContent object
static async Task<DataContent> DownloadImageAsDataContentAsync(
    HttpClient httpClient,
    Uri imageUri,
    string mediaType = "image/jpeg")
{
    byte[] bytes = await httpClient.GetByteArrayAsync(imageUri);
    return new DataContent(bytes, mediaType);
}

// Set the system prompt to behave like a decision intelligence assistant (persona)
var systemVisualDecisionPrompt = """
You are a helpful expert visual estimator and decision-maker.

CRITICAL FIRST STEP (MANDATORY):
Before doing anything else, determine whether an image input is actually present in the request.

- If NO image is present or accessible:
  Respond EXACTLY with:
  Image not provided
  Do not add anything else.
  Do not attempt visual reasoning.
  Do not guess or hallucinate.

- If an image IS present:
  Proceed with visual inspection.

----------------------------------

VISUAL INSPECTION (ONLY if image exists):
Carefully analyze the image using only visible evidence:
- Objects, materials, and conditions
- Sizes, proportions, and layout
- Visible defects, anomalies, or notable features
- Context clues (environment, lighting, usage)

Do NOT infer details that are not clearly visible.

----------------------------------

OUTPUT RULES:

If NO image:
Image not provided

If image IS present:
Return ONLY a single integer.
Do not include any explanation, reasoning, or extra text.
Do not include labels, words, or formatting.

----------------------------------

VALID OUTPUT EXAMPLES:
12
100
1234
5443
45
""";

// Simple instruction prompt to plan retirement
var collectiveIntelligencePromptMultipleImages = """
You have an image of a glass with Hershey's Kisses chocolates.
There is a soda can, soda bottle and a single hershey kiss outside provided for scale.

Reference objects for scale (present in every photo)
- A 12 oz (355 ml) soda can
- A 8 oz (237 ml) soda bottle
- A single wrapped Hershey's Kiss placed outside the glass

Estimate the number of Hershey's Kisses in the a clear glass shown in five images.
Think through the estimate clearly using all 5 of the available information in all of the images.
""";

// Uris of a 5 images of a Hershey's Kisses in a glass
Uri githubImageUri1 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses1.jpg");
Uri githubImageUri2 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses2.jpg");
Uri githubImageUri3 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses3.jpg");
Uri githubImageUri4 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses4.jpg");
Uri githubImageUri5 = new(
    "../Images/CodeExercises/CollectiveIntelligence/HersheyKisses5.jpg");

// Download & Cache the images as DataContent objects
var dataContentUri1 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri1);
var dataContentUri2 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri2);
var dataContentUri3 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri3);
var dataContentUri4 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri4);
var dataContentUri5 = await DownloadImageAsDataContentAsync(new HttpClient(), githubImageUri5);


// Create new decision puzzle chat messages
var chatMessagesCollectiveIntelligenceVisualInspection = new List<ChatMessage>();
// Add system message
var systemMessage = new ChatMessage(ChatRole.System, systemVisualDecisionPrompt);
chatMessagesCollectiveIntelligenceVisualInspection.Add(systemMessage);

// Add user message
// Build a multi-part user message
var userMessage = new ChatMessage();
userMessage.Role = ChatRole.User;
// Add Text Content
userMessage.Contents.Add(new TextContent(collectiveIntelligencePromptMultipleImages));
// Add images
userMessage.Contents.Add(dataContentUri1);
userMessage.Contents.Add(dataContentUri2);
userMessage.Contents.Add(dataContentUri3);
userMessage.Contents.Add(dataContentUri4);
userMessage.Contents.Add(dataContentUri5);
chatMessagesCollectiveIntelligenceVisualInspection.Add(userMessage);

// Execute the chat messages against the AI model
var collectiveIntelligenceVisualInspectionResponse = await chatClient.GetResponseAsync(chatMessagesCollectiveIntelligenceVisualInspection);
var collectiveIntelligenceVisualInspectionResponseText = collectiveIntelligenceVisualInspectionResponse.Text;

// Display the reasoning summary as Markdown
("### **Evaluation:**").DisplayAs("text/markdown");
collectiveIntelligenceVisualInspectionResponseText.DisplayAs("text/markdown");

using System.Globalization;

#pragma warning disable OPENAI001

// Reuse the same responses client and run 10 times
const int numberOfRuns = 10;
var numericResponses = new List<int>();
var rawResponses = new List<string>();
var actualNumberOfKisses = 50; // The actual number of kisses in the glass, used for reference but not provided to the model

// Add options to enable reasoning and include the reasoning summary in the response
var chatReasoningOptions = new ChatOptions
{
    RawRepresentationFactory = _ => new CreateResponseOptions
    {
        Model = azureOpenAIModelDeploymentName,
        ReasoningOptions = new ResponseReasoningOptions
        {
            ReasoningEffortLevel = ResponseReasoningEffortLevel.High,
            // ReasoningSummaryVerbosity = ResponseReasoningSummaryVerbosity.Detailed
        },
        StoredOutputEnabled = false
    }
};

int successfulNumericRuns = 0;
int attempt = 0;
while (successfulNumericRuns < 10)
{
    attempt++;

    ChatResponse response =
        await chatClient.GetResponseAsync(
            chatMessagesCollectiveIntelligenceVisualInspection,
            chatReasoningOptions);

    string responseText = (response.Text ?? string.Empty).Trim();
    rawResponses.Add(responseText);

    if (int.TryParse(responseText, NumberStyles.Integer, CultureInfo.InvariantCulture, out int value))
    {
        successfulNumericRuns++;

        int distanceFromActual = value - actualNumberOfKisses;
        Console.WriteLine(
            $"Run {successfulNumericRuns}: Numeric response: '{responseText}', Distance from actual: {distanceFromActual}");

        numericResponses.Add(value);
    }
    else
    {
        Console.WriteLine(
            $"Attempt {attempt}: non-numeric response: '{responseText}' (does not count toward the 10)");
    }
}

// Guard against all runs failing to parse
if (numericResponses.Count == 0)
{
    throw new InvalidOperationException(
        "No numeric responses were returned. Check the system prompt and model output.");
}

double average = numericResponses.Average();
int minimum = numericResponses.Min();
int maximum = numericResponses.Max();
// Average distance from actual
double averageDistanceFromActual = Math.Abs(average - actualNumberOfKisses);

// Display summary
("### **Summary Statistics:**").DisplayAs("text/markdown");
$"""
- Valid numeric responses: **{numericResponses.Count} / {numberOfRuns}**
- Average: **{average:F2}**
- Minimum: **{minimum}**
- Maximum: **{maximum}**
- Average distance from actual: **{averageDistanceFromActual:F2}**
""".DisplayAs("text/markdown");