Introdução
A IA generativa refere-se a modelos de aprendizagem que podem gerar texto, imagens e outros conteúdos com base nos dados nos quais foram treinados. Ela pode realizar autoria assistida, resumos, recomendações, etc, além de ampliar as aplicações de negócios, por exemplo, gerando automaticamente um rascunho ou uma descrição de produto, ou resumindo concisamente um artigo para responder a uma consulta de suporte de um cliente.
Neste post, exploraremos o uso do OCI Generative AI para desenvolver uma aplicação baseado em LLM (Large Language Model). Essa aplicação usa prompts dinâmicos, que são entradas do usuário ou do programa fornecidas a um LLM. Ao contrário dos prompts codificados, os dinâmicos são gerados instantaneamente, incorporando entradas do usuário, fontes não estáticas, como chamadas de API, e uma string de modelo fixa. Usaremos o LangChain para os prompts dinâmicos. O Langchain facilita interações contínuas com modelos de linguagem, suportando vários recursos como modelos e cadeias de prompt, analisadores de saída e integração de vários componentes e recursos, como APIs e bancos de dados. Explore outros recursos do Langchain para criar aplicações de LLM robustas.
Observe que o OCI Generative AI está atualmente na versão Beta.
Arquitetura
Vamos considerar um caso de uso prático: criar uma aplicação que gere descrições de cargos com base em entradas dinâmicas, como habilidades, funções, anos de experiência e responsabilidades. O diagrama a seguir descreve a arquitetura de referência.
A arquitetura usa os seguintes componentes:
OCI Generative AI (Beta) é um serviço totalmente gerenciado que fornece grandes modelos de linguagem (LLMs) personalizáveis. Você pode usar o playground para testar os modelos pré-treinados prontos para uso ou criar e hospedar seus próprios modelos personalizados ajustados com base em seus dados em clusters de IA dedicados.
OCI Functions é uma plataforma de funções como serviço totalmente gerenciada, multitenant, altamente escalável e sob demanda.
OCI API Gateway permite publicar APIs com endpoints privados que são acessíveis de dentro da sua rede e que você pode expor com endereços de IP públicos se quiser que eles aceitem tráfego da internet.
Visual Builder é uma ferramenta de desenvolvimento de aplicações baseada em navegador que permite criar e implementar interfaces web, móveis e web progressivas.
Etapas
Observe que você precisa adicionar as políticas do IAM necessárias para que vários serviços da OCI funcionem juntos.
1. O OCI Generative AI fornece um conjunto de modelos básicos pré-treinados. Você pode selecionar o modelo básico no playground para testar e refinar prompts e parâmetros. Quando estiver satisfeito com os resultados, copie o código gerado no playground para incorporar em sua aplicação. Você pode tentar prompts estáticos no playground e alterá-los posteriormente para prompts dinâmicos em seu código.
A seguir está uma descrição do uso do playground para testar seus prompts e obter o código de exemplo.
Para ilustrar, o playground do OCI Generative AI, conforme mostrado na imagem abaixo, permite que os usuários selecionem um modelo e configurem parâmetros para seus prompts. A opção ‘View Code’ permite visualizar o código gerado automaticamente para executar o prompt usando SDKs do OCI Generative AI.
2. A próxima etapa é criar uma função do OCI Functions que usa código gerado automaticamente pelo OCI Generative AI obtido no playground.
Para começar, crie uma aplicação do OCI Functions e defina os parâmetros de configuração de aplicação, o endpoint de serviço do OCI Generative AI e o OCID do compartimento do Generative AI. Esses parâmetros serão usados dentro do código da função.
Em seguida, crie no OCI Function uma função python,fn_genai_jobdescription.
func.yaml
schema_version: 20180708
name: fn_genai_jobdescription
version: 0.0.251
runtime: python
build_image: fnproject/python:3.8-dev
run_image: fnproject/python:3.8
entrypoint: /python/bin/fdk /function/func.py handler
memory: 2048
O conteúdo da func.py é mostrado nas seções abaixo.
Importe os módulos necessários
import io
import json
import logging
import os
import oci.auth.signers
import oci.generative_ai
from langchain.prompts import PromptTemplate
from fdk import response
Leia o endpoint de serviço e o OCID do compartimento do OCI Generative AI nos parâmetros da Aplicação de Função. Defina as entidades de recurso do assinante e configure o GenerativeAiClient.
try:
endpoint = os.getenv("SERVICE_ENDPOINT")
compartment_ocid = os.getenv("COMPARTMENT_OCID")
if not endpoint:
raise ValueError("ERROR: Missing configuration key SERVICE_ENDPOINT")
if not compartment_ocid:
raise ValueError("ERROR: Missing configuration key COMPARTMENT_OCID")
signer = oci.auth.signers.get_resource_principals_signer()
generative_ai_client = oci.generative_ai.GenerativeAiClient(config={}, service_endpoint=endpoint, signer=signer,
retry_strategy=oci.retry.NoneRetryStrategy())
except Exception as e:
logging.getLogger().error(e)
raise
Use modelos de prompt do Langchain para construir um prompt dinâmico. Para simplificar, aqui assumimos que o usuário inserirá todas as variáveis do prompt. As opções para definir as variáveis dinâmicas são diversas, digamos que a entrada pode ser uma resposta da API REST, uma chamada SQL do banco de dados, etc.
Inicialize oci.generative_ai.models.GenerateTextDetails() com prompt, parâmetros de LLM, etc. e chame o método generate_text() para gerar a saída de texto.
Insira as variáveis de entrada para o modelo de prompt são habilidades, função, experiência e qualificações.
def generate_job_description(skills, role, experience, qualifications,generative_ai_client):
prompt = PromptTemplate(
input_variables=["skills", "role", "experience","qualifications"],
template="Generate a job description with skills {skills} for a role {role} having experience of {experience}. The qualifications expected from the candidate are {qualifications}"
)
generate_text_detail = oci.generative_ai.models.GenerateTextDetails()
prompts = [prompt.format(skills=skills, role=role, experience=experience,qualifications=qualifications)]
generate_text_detail.prompts = prompts
generate_text_detail.serving_mode = oci.generative_ai.models.OnDemandServingMode(model_id="cohere.command")
generate_text_detail.compartment_id = compartment_ocid
generate_text_detail.max_tokens = 300
generate_text_detail.temperature = 0.7
generate_text_detail.frequency_penalty = 0
generate_text_detail.top_p = 0.75
try:
generate_text_response = generative_ai_client.generate_text(generate_text_detail)
text_response = json.loads(str(generate_text_response.data))
return text_response["generated_texts"][0][0]["text"]
except Exception as e:
logging.getLogger().error(e)
raise
Finalmente, defina o método handler() da função.
def handler(ctx, data: io.BytesIO = None):
try:
body = json.loads(data.getvalue())
skills = body["skills"]
role = body["role"]
experience = body["experience"]
job_description = generate_job_description(skills, role, experience, generative_ai_client)
return response.Response(ctx, response_data=job_description)
except Exception as handler_error:
logging.getLogger().error(handler_error)
return response.Response(
ctx,
status_code=500,
response_data="Processing failed due to " + str(handler_error)
)
Implemente a função usando
fn -v deploy --app <Function application name>
3. Exponha a função usando um gateway de API.
Crie uma implementação do gateway de API.
Crie uma nova Rota. Insira um caminho, método como POST e selecione o tipo de back-end como função.
Escolha fn_genai_jobdescription como a função a ser invocada.
Anote a URL de implementação. Isso será usado nas configurações de conexão de serviço no Visual Builder.
O exemplo de chamada da API REST usando a URL de implementação do gateway de API terá a aparência abaixo.
curl --location 'https://af...t3ea.apigateway.us-ashburn-1.oci.customer-oci.com/genai/generatejobdescription' --header 'Content-Type: application/json' --data '{"skills":"java,spring","experience":"3+ year","role":"developer","responsibilities":"Analyzing user requirements to inform application design.Developing and testing software."}'
Visual Builder
1. Crie uma conexão de serviço com o endpoint do gateway de API conforme mostrado abaixo.
2. Crie uma página com campos de entrada como habilidades, função, anos de experiência, responsabilidades e um botão com uma Cadeia de Ação invocando o endpoint de conexão de serviço.
3. Clicar no botão Generate (gerar) invocará o OCI Generative AI para gerar uma descrição de cargo com base nos valores fornecidos na entrada de habilidades, experiência, função e responsabilidades.
Conclusão
As aplicações que podem ser criadas combinando OCI Generative AI, Langchain e outros serviços da OCI são ilimitadas – libere sua criatividade e explore as possibilidades que estão por vir!