Merge pull request #10 from paulyuk/main

Modernized for updated Langchain, Flex Consumption and MI

Author: paulyuk

README.md

@@ -26,23 +26,28 @@ This sample shows how to take a human prompt as HTTP Get or Post input, calculat
 ### Pre-reqs
 1) [Python 3.8+](https://www.python.org/) 
 2) [Azure Functions Core Tools](https://learn.microsoft.com/en-us/azure/azure-functions/functions-run-local?tabs=v4%2Cmacos%2Ccsharp%2Cportal%2Cbash#install-the-azure-functions-core-tools)
-3) [Azure OpenAPI API key, endpoint, and deployment](https://portal.azure.com) 
-4) Add this `local.settings.json` file to this folder to simplify local development and include Key from step 3
+3) [Azure Developer CLI](https://aka.ms/azd)
+4) Once you have your Azure subscription, run the following in a new terminal window to create Azure OpenAI and other resources needed:
+```bash
+azd provision
+```
+
+Take note of the value of `AZURE_OPENAI_ENDPOINT` which can be found in `./.azure/<env name from azd provision>/.env`.  It will look something like:
+```bash
+AZURE_OPENAI_ENDPOINT="https://cog-<unique string>.openai.azure.com/"
+```
 
-`./local.settings.json`
+5) Add this `local.settings.json` file to the root of the repo folder to simplify local development.  Replace `AZURE_OPENAI_ENDPOINT` with your value from step 4.  Optionally you can choose a different model deployment in `AZURE_OPENAI_CHATGPT_DEPLOYMENT`.  This file will be gitignored to protect secrets from committing to your repo, however by default the sample uses Entra identity (user identity and mananaged identity) so it is secretless.  
 ```json
 {
   "IsEncrypted": false,
   "Values": {
     "FUNCTIONS_WORKER_RUNTIME": "python",
     "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
-    "AzureWebJobsStorage": "",
-    "AZURE_OPENAI_KEY": "...",
-    "AZURE_OPENAI_ENDPOINT": "https://<service_name>.openai.azure.com/",
-    "AZURE_OPENAI_SERVICE": "...",
-    "AZURE_OPENAI_CHATGPT_DEPLOYMENT": "...",
-    "OPENAI_API_VERSION": "2023-05-15",
-    "USE_LANGCHAIN": "True"
+    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
+    "AZURE_OPENAI_ENDPOINT": "https://<your deployment>.openai.azure.com/",
+    "AZURE_OPENAI_CHATGPT_DEPLOYMENT": "chat",
+    "OPENAI_API_VERSION": "2023-05-15"
   }
 }
 ```
@@ -120,3 +125,24 @@ To provision and deploy:
 ```bash
 azd up
 ```
+
+## Source Code
+
+The key code that makes the prompting and completion work is as follows in [function_app.py](function_app.py).  The `/api/ask` function and route expects a prompt to come in the POST body using a standard HTTP Trigger in Python.  Then once the environment variables are set to configure OpenAI and LangChain frameworks, we can leverage favorite aspects of LangChain.  In this simple example we take a prompt, build a better prompt from a template, and then invoke the LLM.  By default the LLM deployment is `gpt-35-turbo` as defined in [./infra/main.parameters.json](./infra/main.parameters.json) but you can experiment with other models.    
+
+```python
+llm = AzureChatOpenAI(
+    deployment_name=AZURE_OPENAI_CHATGPT_DEPLOYMENT,
+    temperature=0.3,
+    openai_api_key=AZURE_OPENAI_KEY
+    )
+llm_prompt = PromptTemplate.from_template(
+    "The following is a conversation with an AI assistant. " +
+    "The assistant is helpful.\n\n" +
+    "A:How can I help you today?\nHuman: {human_prompt}?"
+    )
+formatted_prompt = llm_prompt.format(human_prompt=prompt)
+
+response = llm.invoke(formatted_prompt)
+logging.info(response.content)
+```

azure.yaml

@@ -2,7 +2,7 @@
 
 name: langchain-py-ai-func
 metadata:
-  template: langchain-py-ai-func@0.0.1-beta
+  template: langchain-py-ai-func@1.0.0
 services:
   api:
     project: ./

function_app.py

@@ -2,76 +2,79 @@
 import logging
 import os
 import openai
-from langchain.prompts import PromptTemplate
-from langchain.llms import OpenAI
-from langchain.llms.openai import AzureOpenAI
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import AzureChatOpenAI
+from azure.identity import DefaultAzureCredential
 
 app = func.FunctionApp()
 
-@app.function_name(name='ask')
-@app.route(route='ask', auth_level='anonymous', methods=['POST'])
-def main(req):
 
-    prompt = req.params.get('prompt') 
-    if not prompt: 
-        try: 
-            req_body = req.get_json() 
-        except ValueError: 
-            raise RuntimeError("prompt data must be set in POST.") 
-        else: 
-            prompt = req_body.get('prompt') 
-            if not prompt:
-                raise RuntimeError("prompt data must be set in POST.")
+# Initializes Azure OpenAI environment
+def init():
+    global credential
+    global AZURE_OPENAI_ENDPOINT
+    global AZURE_OPENAI_KEY
+    global AZURE_OPENAI_CHATGPT_DEPLOYMENT
+    global OPENAI_API_VERSION
+
+    # Use the Entra Id DefaultAzureCredential to get the token
+    credential = DefaultAzureCredential()
+    # Set the API type to `azure_ad`
+    os.environ["OPENAI_API_TYPE"] = "azure_ad"
+    # Set the API_KEY to the token from the Azure credential
+    os.environ["OPENAI_API_KEY"] = credential.get_token(
+        "https://cognitiveservices.azure.com/.default"
+        ).token
 
-    # init OpenAI: Replace these with your own values, either in environment variables or directly here
-    USE_LANGCHAIN = os.getenv("USE_LANGCHAIN", 'True').lower() in ('true', '1', 't')
-    AZURE_OPENAI_KEY = os.environ.get("AZURE_OPENAI_KEY")
+    # Initialize Azure OpenAI environment
     AZURE_OPENAI_ENDPOINT = os.environ.get("AZURE_OPENAI_ENDPOINT")
-    AZURE_OPENAI_SERVICE = os.environ.get("AZURE_OPENAI_SERVICE") or "myopenai"
-    AZURE_OPENAI_GPT_DEPLOYMENT = os.environ.get("AZURE_OPENAI_GPT_DEPLOYMENT") or "davinci"
-    AZURE_OPENAI_CHATGPT_DEPLOYMENT = os.environ.get("AZURE_OPENAI_CHATGPT_DEPLOYMENT") or "chat" #GPT turbo
-    if 'AZURE_OPENAI_KEY' not in os.environ:
-        raise RuntimeError("No 'AZURE_OPENAI_KEY' env var set.  Please see Readme.")
+    AZURE_OPENAI_KEY = credential.get_token(
+        "https://cognitiveservices.azure.com/.default"
+        ).token
+    AZURE_OPENAI_CHATGPT_DEPLOYMENT = os.environ.get(
+        "AZURE_OPENAI_CHATGPT_DEPLOYMENT") or "chat"
+    OPENAI_API_VERSION = os.environ.get(
+        "OPENAI_API_VERSION") or "2023-05-15"
 
-    # configure azure openai for langchain and/or llm
+    # Configure base OpenAI framework for LangChain and/or llm
     openai.api_key = AZURE_OPENAI_KEY
-    openai.api_base = AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
-    openai.api_type = 'azure'
-    openai.api_version = '2023-05-15' # this may change in the future
-                                      # for langchain, set this version in environment variables using OPENAI_API_VERSION
+    openai.api_base = AZURE_OPENAI_ENDPOINT
+    openai.api_type = "azure"
+    openai.api_version = OPENAI_API_VERSION
 
-    if bool(USE_LANGCHAIN):
-        logging.info('Using Langchain')
 
-        llm = AzureOpenAI(deployment_name=AZURE_OPENAI_CHATGPT_DEPLOYMENT, temperature=0.3, openai_api_key=AZURE_OPENAI_KEY)
-        llm_prompt = PromptTemplate(
-            input_variables=["human_prompt"],
-            template="The following is a conversation with an AI assistant. The assistant is helpful.\n\nAI: I am an AI created by OpenAI. How can I help you today?\nHuman: {human_prompt}?",
-        )
-        from langchain.chains import LLMChain
-        chain = LLMChain(llm=llm, prompt=llm_prompt)
-        return chain.run(prompt)
-
-    else:
-        logging.info('Using ChatGPT LLM directly')
+# Initialize Azure OpenAI environment
+init()
 
-        completion = openai.Completion.create(
-            engine=AZURE_OPENAI_CHATGPT_DEPLOYMENT,
-            prompt=generate_prompt(prompt),
-            temperature=0.3,
-            max_tokens=200
-        )
-        return completion.choices[0].text
 
+# Function App entry point route for /api/ask
+@app.function_name(name="ask")
+@app.route(route="ask", auth_level="function", methods=["POST"])
+def main(req):
 
-def generate_prompt(prompt):
-    capitalized_prompt = prompt.capitalize()
+    try:
+        req_body = req.get_json()
+        prompt = req_body.get("prompt")
+    except ValueError:
+        raise RuntimeError("prompt data must be set in POST.")
+    else:
+        if not prompt:
+            raise RuntimeError("prompt data must be set in POST.")
 
-    # Chat
-    return f'The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.\n\nHuman: Hello, who are you?\nAI: I am an AI created by OpenAI. How can I help you today?\nHuman: {capitalized_prompt}' 
+    # LangChain user code goes here
+    llm = AzureChatOpenAI(
+        deployment_name=AZURE_OPENAI_CHATGPT_DEPLOYMENT,
+        temperature=0.3
+        )
+    llm_prompt = PromptTemplate.from_template(
+        "The following is a conversation with an AI assistant. " +
+        "The assistant is helpful.\n\n" +
+        "A:How can I help you today?\n" +
+        "Human: {human_prompt}?"
+        )
+    formatted_prompt = llm_prompt.format(human_prompt=prompt)
 
-    # Classification
-    #return 'The following is a list of companies and the categories they fall into:\n\nApple, Facebook, Fedex\n\nApple\nCategory: ' 
+    response = llm.invoke(formatted_prompt)
+    logging.info(response.content)
 
-    # Natural language to Python
-    #return '\"\"\"\n1. Create a list of first names\n2. Create a list of last names\n3. Combine them randomly into a list of 100 full names\n\"\"\"'
+    return func.HttpResponse(response.content)

infra/app/ai-Cog-Service-Access.bicep

@@ -0,0 +1,21 @@
+param principalID string
+param principalType string = 'ServicePrincipal' // Workaround for https://learn.microsoft.com/en-us/azure/role-based-access-control/role-assignments-template#new-service-principal
+param roleDefinitionID string
+param aiResourceName string
+
+resource cognitiveService 'Microsoft.CognitiveServices/accounts@2023-05-01' existing = {
+  name: aiResourceName
+}
+
+// Allow access from API to this resource using a managed identity and least priv role grants
+resource roleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
+  name: guid(cognitiveService.id, principalID, roleDefinitionID)
+  scope: cognitiveService
+  properties: {
+    roleDefinitionId: resourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionID)
+    principalId: principalID
+    principalType: principalType 
+  }
+}
+
+output ROLE_ASSIGNMENT_NAME string = roleAssignment.name

infra/app/ai.bicep

@@ -1,47 +1,50 @@
 param name string
 param location string = resourceGroup().location
 param tags object = {}
-
-param allowedOrigins array = []
 param applicationInsightsName string = ''
 param appServicePlanId string
 param appSettings object = {}
-param keyVaultName string
+param runtimeName string 
+param runtimeVersion string 
 param serviceName string = 'api'
 param storageAccountName string
-param openAiAccountName string
-param openAiResourceGroupName string
+param deploymentStorageContainerName string
+param virtualNetworkSubnetId string = ''
+param instanceMemoryMB int = 2048
+param maximumInstanceCount int = 100
+param identityId string = ''
+param identityClientId string = ''
+param aiServiceUrl string = ''
+
+var applicationInsightsIdentity = 'ClientId=${identityClientId};Authorization=AAD'
 
-module api '../core/host/functions.bicep' = {
-  name: '${serviceName}-functions-python-module'
+module api '../core/host/functions-flexconsumption.bicep' = {
+  name: '${serviceName}-functions-module'
   params: {
     name: name
     location: location
     tags: union(tags, { 'azd-service-name': serviceName })
-    allowedOrigins: allowedOrigins
-    alwaysOn: false
-    appSettings: union(appSettings, {
-        AZURE_OPENAI_KEY: openai.listKeys().key1
+    identityType: 'UserAssigned'
+    identityId: identityId
+    appSettings: union(appSettings,
+      {
+        AzureWebJobsStorage__clientId : identityClientId
+        APPLICATIONINSIGHTS_AUTHENTICATION_STRING: applicationInsightsIdentity
+        AZURE_OPENAI_ENDPOINT: aiServiceUrl
+        AZURE_CLIENT_ID: identityClientId
       })
     applicationInsightsName: applicationInsightsName
     appServicePlanId: appServicePlanId
-    keyVaultName: keyVaultName
-    //py
-    numberOfWorkers: 1
-    minimumElasticInstanceCount: 0
-    //--py
-    runtimeName: 'python'
-    runtimeVersion: '3.9'
+    runtimeName: runtimeName
+    runtimeVersion: runtimeVersion
     storageAccountName: storageAccountName
-    scmDoBuildDuringDeployment: false
+    deploymentStorageContainerName: deploymentStorageContainerName
+    virtualNetworkSubnetId: virtualNetworkSubnetId
+    instanceMemoryMB: instanceMemoryMB 
+    maximumInstanceCount: maximumInstanceCount
   }
 }
 
-resource openai 'Microsoft.CognitiveServices/accounts@2023-05-01' existing = {
-  name: openAiAccountName
-  scope: resourceGroup(openAiResourceGroupName)
-}
-
-output SERVICE_API_IDENTITY_PRINCIPAL_ID string = api.outputs.identityPrincipalId
 output SERVICE_API_NAME string = api.outputs.name
 output SERVICE_API_URI string = api.outputs.uri
+output SERVICE_API_IDENTITY_PRINCIPAL_ID string = api.outputs.identityPrincipalId