private async Task CognitiveServices_QnA_MigrationGuide_Runtime()
{
#region Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_CreateRuntimeClient
EndpointKeyServiceClientCredentials credential = new EndpointKeyServiceClientCredentials("{ApiKey}");
QnAMakerRuntimeClient client = new QnAMakerRuntimeClient(credential)
{
RuntimeEndpoint = "{QnaMakerEndpoint}"
};
#endregion Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_CreateRuntimeClient
#region Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_QueryKnowledgeBase
QueryDTO queryDTO = new QueryDTO();
queryDTO.Question = "{Question}";
QnASearchResultList response = await client.Runtime.GenerateAnswerAsync("{knowledgebase-id}", queryDTO);
#endregion Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_QueryKnowledgeBase
#region Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_Chat
QueryDTO queryDTOFollowUp = new QueryDTO();
queryDTOFollowUp.Context = new QueryDTOContext(previousQnaId: 1);
QnASearchResultList responseFollowUp = await client.Runtime.GenerateAnswerAsync("{knowledgebase-id}", queryDTO);
#endregion Snippet:CognitiveServices_QnA_Maker_Snippets_MigrationGuide_Chat
}
// <Main>
static void Main(string[] args)
{
// <Resourcevariables>
var authoringKey = "QNA_MAKER_SUBSCRIPTION_KEY";
var authoringURL = "QNA_MAKER_ENDPOINT";
var queryingURL = "QNA_MAKER_RUNTIME_ENDPOINT";
// </Resourcevariables>
// <AuthorizationAuthor>
var client = new QnAMakerClient(new ApiKeyServiceClientCredentials(authoringKey))
{
Endpoint = authoringURL
};
// </AuthorizationAuthor>
var kbId = CreateSampleKb(client).Result;
UpdateKB(client, kbId).Wait();
PublishKb(client, kbId).Wait();
DownloadKb(client, kbId).Wait();
var primaryQueryEndpointKey = GetQueryEndpointKey(client).Result;
// <AuthorizationQuery>
var runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(primaryQueryEndpointKey))
{
RuntimeEndpoint = queryingURL
};
// </AuthorizationQuery>
GenerateAnswer(runtimeClient, kbId).Wait();
DeleteKB(client, kbId).Wait();
}
/// <summary>
/// Initializes a new instance of the <see cref="QnaServiceProvider"/> class.
/// </summary>
/// <param name="configurationProvider">ConfigurationProvider fetch and store information in storage table.</param>
/// <param name="optionsAccessor">A set of key/value application configuration properties.</param>
/// <param name="qnaMakerClient">Qna service client.</param>
/// <param name="qnaMakerRuntimeClient">Qna service runtime client.</param>
public QnaServiceProvider(IConfigurationDataProvider configurationProvider, IOptionsMonitor<QnAMakerSettings> optionsAccessor, IQnAMakerClient qnaMakerClient, QnAMakerRuntimeClient qnaMakerRuntimeClient)
{
this.configurationProvider = configurationProvider;
this.qnaMakerClient = qnaMakerClient;
this.options = optionsAccessor.CurrentValue;
this.qnaMakerRuntimeClient = qnaMakerRuntimeClient;
}
public async Task <QnASearchResultList> AnswerQuestion(string question, string userId, int resultCount = 1)
{
//From QnA Knowledgebase - embedded GUID in POST portion
var runtimeKB = _configuration["QNA_KB_ID"];
//From QnA Knowledgebase - HOST
var runtimeEndpoint = _configuration["QNA_RuntimeEndpoint"];
//From QnA Knowledgebase - Authorization Endpoint Key
var runtimeKey = _configuration["QNA_RuntimeKey"];
var runtimeCreds = new EndpointKeyServiceClientCredentials(runtimeKey);
//Runtime client for asking questions
using (QnAMakerRuntimeClient rtClient = new QnAMakerRuntimeClient(runtimeCreds)
{
RuntimeEndpoint = runtimeEndpoint
})
{
QueryDTO query = new QueryDTO()
{
Question = question, //The text of the question
ScoreThreshold = 0.55, //The minimum relevance score to accept
Top = resultCount //How many answers to return, maximum
};
return(await rtClient.Runtime.GenerateAnswerAsync(runtimeKB, query).ConfigureAwait(false));
}
}
private async void CommandBinding_Executed_CheckConnection(object sender, ExecutedRoutedEventArgs e)
{
string EndPoint = Properties.Settings.Default.EndPoint;
string Key = Properties.Settings.Default.Key;
string Id = Properties.Settings.Default.Id;
QnAMakerRuntimeClient client = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
try
{
string pregunta = "hola";
QnASearchResultList response = await client.Runtime.GenerateAnswerAsync(Id, new QueryDTO { Question = pregunta });
string respuesta = response.Answers[0].Answer;
MessageBox.Show("Conexion realizada con exito", "Comprobar conexion", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception)
{
MessageBox.Show("No se ha podido completar la conexion...", "Comprobar conexion", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private async void MandarMensaje_CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
{
mensajes.Add(new Mensaje(false, ChatTextBox.Text));
Mensaje mensajeBot = new Mensaje(true, "Pensando...");
mensajes.Add(mensajeBot);
string respuesta = "";
try
{
var cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Properties.Settings.Default.EndPointKey))
{
RuntimeEndpoint = Properties.Settings.Default.EndPoint
};
QnASearchResultList response = await cliente.Runtime.GenerateAnswerAsync(Properties.Settings.Default.KnowledgeBaseId, new QueryDTO { Question = ChatTextBox.Text });
respuesta = response.Answers[0].Answer;
}
catch (IOException)
{
respuesta = "Estoy muy cansado para hablar";
}
mensajeBot.Texto = respuesta;
ChatTextBox.Text = "";
ChatScrollViewer.ScrollToVerticalOffset(ChatScrollViewer.ExtentHeight);
}
// <Main>
static void Main(string[] args)
{
var authoringKey = "REPLACE-WITH-YOUR-QNA-MAKER-KEY";
var resourceName = "REPLACE-WITH-YOUR-RESOURCE-NAME";
// <AuthorizationAuthoring>
var client = new QnAMakerClient(new ApiKeyServiceClientCredentials(authoringKey))
{
Endpoint = $"https://{resourceName}.cognitiveservices.azure.com"
};
// </AuthorizationAuthoring>
var kbId = CreateSampleKb(client).Result;
UpdateKB(client, kbId).Wait();
PublishKb(client, kbId).Wait();
DownloadKb(client, kbId).Wait();
var primaryPredictionEndpointKey = GetPredictionEndpointKey(client).Result;
// <AuthorizationPrediction>
var runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(primaryPredictionEndpointKey))
{
RuntimeEndpoint = $"https://{resourceName}.azurewebsites.net"
};
// </AuthorizationPrediction>
GenerateAnswer(runtimeClient, kbId).Wait();
DeleteKB(client, kbId).Wait();
}
private async Task ObtenRespuestaBotAsync(string pregunta, int indice)
{
try
{
string EndPoint = Properties.Settings.Default.EndPoint;
string EndPointKey = Properties.Settings.Default.EndPointKey;
string KnowledgeBaseId = Properties.Settings.Default.KnowledgeBaseId;
QnAMakerRuntimeClient cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(EndPointKey))
{
RuntimeEndpoint = EndPoint
};
//Realizamos la pregunta a la API
QnASearchResultList response = await(cliente.Runtime.GenerateAnswerAsync(KnowledgeBaseId, new QueryDTO {
Question = pregunta
}));
string respuesta = response.Answers[0].Answer;
mensajes[indice].Mensaje = respuesta;
}
catch (Exception ex)
{
string messageBoxText = ex.Message;
string caption = "Error Bot";
MessageBoxButton button = MessageBoxButton.OK;
MessageBoxImage icon = MessageBoxImage.Error;
MessageBox.Show(messageBoxText, caption, button, icon);
mensajes[indice].Mensaje = "No he podifo obtener una respuesta.";
}
}
private async void ComprobarConexion_Executed(object sender, ExecutedRoutedEventArgs e)
{
try
{
string EndPoint = Properties.Settings.Default.EndPoint;
string EndPointKey = Properties.Settings.Default.EndPointKey;
string KnowledgeBaseId = Properties.Settings.Default.KnowledgeBaseId;
QnAMakerRuntimeClient cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(EndPointKey))
{
RuntimeEndpoint = EndPoint
};
//Realizamos la pregunta a la API
QnASearchResultList response = await(cliente.Runtime.GenerateAnswerAsync(KnowledgeBaseId, new QueryDTO {
Question = "Hola"
}));
_ = response.Answers[0].Answer;
string messageBoxText = "Conexión correcta con el servidor del Bot";
string caption = "Comprobar conexión";
MessageBoxButton button = MessageBoxButton.OK;
MessageBoxImage icon = MessageBoxImage.Information;
MessageBox.Show(messageBoxText, caption, button, icon);
}
catch (Exception)
{
string caption = "Error Bot";
MessageBoxButton button = MessageBoxButton.OK;
MessageBoxImage icon = MessageBoxImage.Error;
MessageBox.Show("No se ha podido establecer la conexión con el servidor del bot", caption, button, icon);
}
}
/// <summary>
/// Service Collection extension.
///
/// Injects concrete implementation of QnAService.
/// </summary>
/// <param name="services">Service collection.</param>
/// <param name="configuration">Configuration.</param>
/// <returns>Service Collection.</returns>
public static IServiceCollection AddQnAService(this IServiceCollection services, IConfiguration configuration)
{
// Add QnAMakerClient
var subscriptionKey = configuration.GetValue <string>("QnAMaker:SubscriptionKey");
var endpoint = configuration.GetValue <string>("QnAMaker:Endpoint");
var qnaMakerClient = new QnAMakerClient(new ApiKeyServiceClientCredentials(subscriptionKey))
{
Endpoint = endpoint,
};
services.AddSingleton <IQnAMakerClient>(qnaMakerClient);
// Add QnAMakerRuntimeClient
var runtimeEndpoint = configuration.GetValue <string>("QnAMaker:RuntimeEndpoint");
var endpointKey = configuration.GetValue <string>("QnAMaker:EndpointKey");
var qnaMakerRuntimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(endpointKey))
{
RuntimeEndpoint = runtimeEndpoint,
};
services.AddSingleton <IQnAMakerRuntimeClient>(qnaMakerRuntimeClient);
// Add QnAServiceSettings
var qnaServiceSettings = new QnAServiceSettings()
{
ScoreThreshold = configuration.GetValue <int>("QnAMaker:ScoreThreshold"),
KnowledgeBaseId = configuration.GetValue <string>("QnAMaker:KnowledgeBaseId"),
};
services.AddSingleton <IQnAServiceSettings>(qnaServiceSettings);
// Add QnAService
services.AddTransient <IQnAService, QnAService>();
return(services);
}
public async Task <string> MensajeRobot(string pregunta)
{
//Para usar la API QnA añadir el paquete NuGet
//Microsoft.Azure.CognitiveServices.Knowledge.QnAMaker
//Creamos el cliente de QnA
string EndPoint = Properties.Settings.Default.EndPoint;
string EndPointKey = Properties.Settings.Default.EndPointKey;
string KnowledgeBaseId = Properties.Settings.Default.KnowledgeBaseId;
var cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(EndPointKey))
{
RuntimeEndpoint = EndPoint
};
hayConexion = true;
//Realizamos la pregunta a la API
try
{
QnASearchResultList response = await cliente.Runtime.GenerateAnswerAsync(KnowledgeBaseId, new QueryDTO { Question = pregunta });
return(response.Answers[0].Answer);
}
catch (Exception)
{
hayConexion = false;
return(null);
}
}
public Bot()
{
cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Properties.Settings.Default.AzureBotKey))
{
RuntimeEndpoint = Properties.Settings.Default.AzureBotEndPoint
};
IsNotProcessing = true;
}
// </DownloadKB>
// <GenerateAnswer>
private static async Task GenerateAnswer(QnAMakerRuntimeClient runtimeClient, string kbId)
{
var response = await runtimeClient.Runtime.GenerateAnswerAsync(kbId, new QueryDTO { Question = "How do I manage my knowledgebase?" });
Console.WriteLine("Endpoint Response: {0}.", response.Answers[0].Answer);
// Do something meaningful with answer
}
// <Main>
static void Main(string[] args)
{
// <AuthoringAuthorization>
string subscriptionKey = "PASTE_YOUR_QNA_MAKER_AUTHORING_SUBSCRIPTION_KEY_HERE";
string endpoint = "PASTE_YOUR_QNA_MAKER_AUTHORING_ENDPOINT_HERE";
// set tryPreview to 'true' for QnAMakerV2 resources
bool tryPreview = false;
var authoringClient = new QnAMakerClient(new ApiKeyServiceClientCredentials(subscriptionKey), tryPreview)
{
Endpoint = endpoint
};
// </AuthoringAuthorization>
// <RuntimeAuthorization>
string runtimeEndpoint = "PASTE_YOUR_QNA_MAKER_RUNTIME_ENDPOINT_HERE";
if (tryPreview)
{
runtimeEndpoint = endpoint;
}
string endpointKey = GetQueryEndpointKey(authoringClient).Result;
QnAMakerRuntimeClient runtimeClient;
if (tryPreview)
{
runtimeClient = new QnAMakerRuntimeClient(new ApiKeyServiceClientCredentials(subscriptionKey), tryPreview)
{
RuntimeEndpoint = runtimeEndpoint
};
}
else
{
runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(endpointKey))
{
RuntimeEndpoint = runtimeEndpoint
};
}
// </RuntimeAuthorization>
Console.WriteLine("Creating KB...");
var kbId = CreateSampleKb(authoringClient).Result;
Console.WriteLine("Created KB with ID " + kbId + ".");
Console.WriteLine("Downloading KB...");
DownloadKb(authoringClient, kbId).Wait();
Console.WriteLine("Updating KB...");
UpdateKB(authoringClient, kbId).Wait();
Console.WriteLine("Publishing KB...");
PublishKb(authoringClient, kbId).Wait();
Console.WriteLine("Querying KB...");
GenerateAnswer(runtimeClient, kbId).Wait();
Console.WriteLine("Deleting KB...");
DeleteKB(authoringClient, kbId).Wait();
}
protected IQnAMakerRuntimeClient GetQnAMakerRuntimeClient(DelegatingHandler handler)
{
IQnAMakerRuntimeClient client = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(QnAMakerEndpointKey), handlers: handler)
{
RuntimeEndpoint = "https://myqnamakerapp.azurewebsites.net"
};
return(client);
}
protected IQnAMakerRuntimeClient GetQnAMakerPreviewRuntimeClient(DelegatingHandler handler)
{
IQnAMakerRuntimeClient client = new QnAMakerRuntimeClient(new ApiKeyServiceClientCredentials(QnAMakerSubscriptionKey), isPreview: true, handlers: handler)
{
RuntimeEndpoint = "https://australiaeast.api.cognitive.microsoft.com"
};
return(client);
}
public QnAService(string endPoint, string key, string id)
{
EndPoint = endPoint;
Key = key;
Id = id;
cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
}
public EchoBot(IConfiguration config)
{
kbId = config["QnAKnowledgeBase"];
qnaClient = new QnAMakerRuntimeClient(
new EndpointKeyServiceClientCredentials(
config["QnAEndpointKey"]))
{
RuntimeEndpoint = $"https://{config["QnAEndpointHost"]}.azurewebsites.net"
};
}
public Bot()
{
string EndPoint = "https://botactividaddint.azurewebsites.net";
string Key = "9c1c31bb-5ad4-44c4-b5f9-c36256871454";
server = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
}
static void Main(string[] args)
{
if (args.Length != 4)
{
var exeName = "batchtesting.exe";
Console.WriteLine($"Usage: {exeName} <tsv-inputfile> <runtime-hostname> <runtime-endpointkey> <tsv-outputfile>");
Console.WriteLine($"{exeName} input.tsv https://myhostname.azurewebsites.net 5397A838-2B74-4E55-8111-D60ED1D7CF7F output.tsv");
Console.WriteLine();
return;
}
var i = 0;
var inputFile = args[i++];
var runtimeHost = args[i++];
var endpointKey = args[i++];
var outputFile = args[i++];
var inputQueries = File.ReadAllLines(inputFile);
var inputQueryData = inputQueries.Select(x => GetTsvData(x)).ToList();
var runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(endpointKey))
{
RuntimeEndpoint = runtimeHost
};
var lineNumber = 0;
File.WriteAllText(outputFile, $"Line\tKbId\tQuery\tAnswer1\tScore1{Environment.NewLine}");
foreach (var queryData in inputQueryData)
{
try
{
lineNumber++;
var(queryDto, kbId) = GetQueryDTO(queryData);
var response = runtimeClient.Runtime.GenerateAnswer(kbId, queryDto);
var resultLine = new List <string>();
resultLine.Add(lineNumber.ToString());
resultLine.Add(kbId);
resultLine.Add(queryDto.Question);
foreach (var answer in response.Answers)
{
resultLine.Add(answer.Answer);
resultLine.Add(answer.Score.ToString());
}
var result = string.Join('\t', resultLine);
File.AppendAllText(outputFile, $"{result}{Environment.NewLine}");
}
catch (Exception ex)
{
Console.WriteLine($"Error processing line : {lineNumber}, {ex}");
}
}
}
public ClienteQnA()
{
string EndPoint = Properties.Settings.Default.Endpoint;
string Key = Properties.Settings.Default.Key;
Id = Properties.Settings.Default.Id;
Cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
}
public Robot()
{
string EndPoint = "https://botmahroz.azurewebsites.net";
string Key = "a5e51ac1-8679-407f-9f42-1d70dadfd230";
Id = "ba514545-ce8f-4d28-8c96-0e30f9aa6f29";
cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
}
// <Main>
static void Main(string[] args)
{
// <Resourcevariables>
var authoringKey = "REPLACE-WITH-YOUR-QNA-MAKER-KEY";
var resourceName = "REPLACE-WITH-YOUR-RESOURCE-NAME";
var authoringURL = $"https://{resourceName}.cognitiveservices.azure.com";
var queryingURL = $"https://{resourceName}.azurewebsites.net";
// </Resourcevariables>
// <TryPreview>
// To be set to 'true' to use QnAMakerV2 Public Preview resources
// Use the package Microsoft.Azure.CognitiveServices.Knowledge.QnAMaker version 2.1.0-preview.1
var tryPreview = false;
// </TryPreview>
// <AuthorizationAuthor>
var client = new QnAMakerClient(new ApiKeyServiceClientCredentials(authoringKey), tryPreview)
{
Endpoint = authoringURL
};
// </AuthorizationAuthor>
var kbId = CreateSampleKb(client).Result;
UpdateKB(client, kbId).Wait();
PublishKb(client, kbId).Wait();
DownloadKb(client, kbId).Wait();
var primaryQueryEndpointKey = GetQueryEndpointKey(client).Result;
// <AuthorizationQuery>
QnAMakerRuntimeClient runtimeClient;
if (tryPreview)
{
runtimeClient = new QnAMakerRuntimeClient(new ApiKeyServiceClientCredentials(authoringKey), tryPreview)
{
RuntimeEndpoint = authoringURL
};
}
else
{
runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(primaryQueryEndpointKey))
{
RuntimeEndpoint = queryingURL
};
}
// </AuthorizationQuery>
GenerateAnswer(runtimeClient, kbId).Wait();
DeleteKB(client, kbId).Wait();
}
public async Task <QnASearchResultList> Post(QueryDTO data)
{
var endpointKey = _configuration["QnAMakerEndpointKey"];
var endpoint = Environment.GetEnvironmentVariable("QnAMakerEndpoint");
var kbId = Environment.GetEnvironmentVariable("QnAMakerKbId");
var client = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(endpointKey))
{
RuntimeEndpoint = endpoint
};
var response = await client.Runtime.GenerateAnswerAsync(kbId, data);
return(response);
}
public async Task <IList <QnASearchResult> > GetQnAResponse(string question)
{
var subscriptionKey = configuration["QnAMakerAPIKey"];
qnAMakerClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(subscriptionKey))
{
RuntimeEndpoint = configuration["QnAMakerEndpoint"]
};
var result = await qnAMakerClient.Runtime.GenerateAnswerAsync("5a60db98-441c-44b4-bbc0-59f70e960d54", new QueryDTO { Question = question });
return(result.Answers);
}
public MainWindow()
{
listaMensajes = new List <Mensaje>();
InitializeComponent();
string EndPoint = "https://botisma.azurewebsites.net";
string Key = "38249f96-77a1-46e2-adf4-f29195b93211";
Id = "e3c48047-80d3-4450-9231-ed4d0985840d";
cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
//MensajesItemsControl.DataContext = listaMensajes;
}
public QnAHandler()
{
authoringKey = "";
resourceName = "qnadietbot1";
authoringURL = $"https://{resourceName}.cognitiveservices.azure.com";
queryingURL = $"https://{resourceName}.azurewebsites.net";
primaryQueryEndpointKey = "";
runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(primaryQueryEndpointKey))
{
RuntimeEndpoint = queryingURL
};
}
protected QnAMakerRuntimeClient GetQnAMakerRuntimeClient(DelegatingHandler handler)
{
// Do not initialize QnAMakerClient with EndpointKeyCredentials.
// The following will fallback to constructor with ServiceCredentials instead.
// var client = new QnAMakerClient(new EndpointKeyServiceClientCredentials(QnAMakerEndpointKey), handler);
// Because, it is a customized 'internal' contructor for backward compatibility with V2.x.x SDK
// Use QnAMakerRuntimeClient instead like below
var client = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(QnAMakerEndpointKey), handlers: handler)
{
RuntimeEndpoint = "https://sk4cs.azurewebsites.net"
};
return(client);
}
//Conexión ------------------------------------------------------------------------------------------------------------------------------------------
private async void Conexion()
{
string EndPoint = "https://botsergio.azurewebsites.net";
string Key = "164b4f7b-d067-439f-9ef9-20d58c3d5ec8";
string Id = "69e93d1d-6ccd-493d-8314-19e007646cf2";
var cliente = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(Key))
{
RuntimeEndpoint = EndPoint
};
//Realizamos la pregunta a la API
string pregunta = "Your question";
QnASearchResultList response = await cliente.Runtime.GenerateAnswerAsync(Id, new QueryDTO { Question = pregunta });
string respuesta = response.Answers[0].Answer;
}
public static async Task <String> GetAnswer(string question)
{
var client = new QnAMakerClient(new ApiKeyServiceClientCredentials(authoringKey))
{
Endpoint = authoringURL
};
var primaryQueryEndpointKey = await GetQueryEndpointKey(client);
var runtimeClient = new QnAMakerRuntimeClient(new EndpointKeyServiceClientCredentials(primaryQueryEndpointKey))
{
RuntimeEndpoint = queryingURL
};
var answer = await GenerateAnswer(runtimeClient, question);
return(answer);
}
