Inteligência Artificial (IA) é a simulação de processos de inteligência humana por máquinas, principalmente sistemas computacionais. Esses processos incluem aprendizagem (a aquisição de informações e regras para usar as informações), raciocínio (usando regras para chegar a conclusões aproximadas ou definitivas) e autocorreção.
Com a rápida adoção da telemedicina, consutlas remotas e digitação digital, profissionais da saúde estão se comunicano mais do que nunca por voz. Pacientes em conversas virtuais geram uma vasta quantidade de dados sonoros não estruturados, então como clínicos e administradores pesquisam e extraem informações d horas de gravações de voz?
Apresentamos o IRIS Audio Query – um aplicativo full-stack que transforma áudio em uma base de conhecimento pesquisável. Com ele, você pode:
Olá Comunidade,
Aproveitem o novo video no InterSystems Developers YouTube:
#InterSystems Demo Games entry
Uma demonstração de texto para sql sobre análise de dados mqtt com RAG.
🗣 Apresentador: @Jeff Liu, Sales Engineer, InterSystems
Oi Comunidade,
Assista a este vídeo para saber mais sobre o AI Co-Pilot, que simplifica a codificação DTL e oferece assistência personalizada, o que o torna acessível a usuários com diferentes níveis de conhecimento técnico:
⏯ Acelere a codificação DTL com o serviço AI Cloud@ Global Summit 2024
Agradeço à comunidade por traduzir um artigo anterior para o português!
Estou retribuindo o favor com um novo lançamento do aplicativo de demonstração Pattern Match Workbench.
Suporte Adicionado para Português.
Agora, as legendas, botões, mensagens de feedback e textos de ajuda da interface do usuário estão atualizados para o português.
Além disso, descrições de padrões podem ser solicitadas no novo idioma.
O único Modelo de IA responsável por transformar o comando do usuário em código de correspondência de padrões foi completamente retreinado.
#InterSystems Demo Games entry
O Care Compass é um protótipo de assistente de IA que auxilia assistentes sociais a priorizar clientes por meio da análise de dados clínicos e sociais. Utilizando a Geração Aumentada de Recuperação (RAG) e modelos de linguagem de grande porte, ele gera resumos narrativos de risco, calcula pontuações de risco dinâmicas e recomenda os próximos passos. O objetivo é reduzir as visitas evitáveis ao pronto-socorro e apoiar intervenções precoces e informadas.
Apresentadores:
🗣 @Brad Nissenbaum, Sales Engineer, InterSystems
🗣 @Andrew Wardly, Sales Engineer, InterSystems
🗣 @Fan Ji, Solution Developer, InterSystems
🗣 @Lynn Wu, Sales Engineer, InterSystems
Aqueles interessados em explorar novos casos de uso da IA Generativa
Compartilha ideias e a lógica por trás do treinamento de IA generativa para reconhecimento de padrões.
Um desenvolvedor aspira a conceber uma solução elegante para requisitos. O reconhecimento de padrões (como expressões regulares) pode ser resolvido de várias maneiras. Qual delas é a melhor solução de código?
Uma IA pode postular uma solução elegante de reconhecimento de padrões para uma variedade de amostras de dados, do simples ao complexo?
Considere os três valores de string:
Em ObjectScript e SQL, esse operador costuma ter um formato bastante denso visualmente.
Exemplo:
if booking?2A1"-"1(1"CARD",1"RAD")1.5NSELECTDISTINCT PatientRef
FROM APPOINTMENT.BOOKING
WHERE Active='Y'AND
LocationCode %PATTERN '2A1"-"1(1"CARD",1"RAD")1.5N'Usar Generative AI para ajudar a criar e modificar códigos de pattern match a partir de descrições em linguagem natural.
Olá, desenvolvedores!
Este será um artigo bem curto, pois em abril de 2025, com o Lovable e outras ferramentas Prompt-to-UI, tornou-se possível construir o frontend com prompting. Até mesmo para pessoas como eu, que não estão nem um pouco familiarizadas com as técnicas modernas de UI.
Bem, eu conheço pelo menos as palavras javascript, typescript e ReactJS, então, neste artigo bem curto, construiremos a UI ReactJS para o servidor InterSystems FHIR com Lovable.ai.
Vamos lá!
Sou um grande fã de ficção científica, mas embora eu esteja totalmente a bordo da nave Star Wars (desculpas aos meus colegas Trekkies!), sempre apreciei os episódios clássicos de Star Trek da minha infância. A tripulação diversificada da USS Enterprise, cada um dominando suas funções únicas, é uma metáfora perfeita para entender os agentes de IA e seu poder em projetos como o Facilis. Então, vamos embarcar em uma missão intergaláctica, utilizando a IA como a tripulação da nossa nave e audaciosamente ir audaciosamente ir homem jamais esteve! Esse conceito de trabalho em equipe é uma analogia maravilhosa para ilustrar como os agentes de IA funcionam e como os usamos em nosso projeto DC-Facilis. Então, vamos mergulhar e assumir o papel de um capitão de nave estelar, liderando uma tripulação de IA em territórios inexplorados!
Para gerenciar nossa tripulação de IA, usamos uma estrutura fantástica chamada CrewAI.É enxuta, extremamente rápida e opera como uma plataforma Python multiagente. Uma das razões pelas quais a amamos, além do fato de ter sido criada por outro brasileiro, é sua incrível flexibilidade e design baseado em funções.
from crewai import Agent, Task, Crew
No Facilis, nossos agentes de IA são divididos em dois grupos. Vamos começar com o primeiro, que gosto de chamar de "Os Planejadores".
O papel principal do Facilis é receber uma descrição em linguagem natural de um serviço REST e criar automaticamente toda a interoperabilidade necessária. Portanto, nosso primeiro membro da tripulação é o Agente de Extração. Este agente tem a tarefa de "extrair" as especificações da API a partir da descrição fornecida pelo usuário.
Aqui está o que o Agente de Extração procura:
def create_extraction_agent(self) -> Agent:
return Agent(
role='Extrator de Especificações de API',
goal='Extrair especificações de API de descrições em linguagem natural',
backstory=dedent("""
Você é especializado em interpretar descrições em linguagem natural
e extrair especificações de API estruturadas.
"""),
allow_delegation=True,
llm=self.llm
)
def extract_api_specs(self, descriptions: List[str]) -> Task:
return Task(
description=dedent(f"""
Extraia as especificações de API das seguintes descrições:
{json.dumps(descriptions, indent=2)}
Para cada descrição, extraia:
- Host (obrigatório)
- Endpoint (obrigatório)
- Params (opcional)
- Port (se disponível)
- modelo JSON (para POST/PUT/PATCH/DELETE)
- Autenticação (se aplicável)
Marque quaisquer campos obrigatórios ausentes como 'missing'.
Retorne os resultados em formato JSON como um array de especificações.
"""),
expected_output="""Um array JSON contendo as especificações de API extraídas com todos os campos obrigatórios e opcionais""",
agent=self.extraction_agent
)
Próximo na fila, o Agente de Validação! Sua missão é garantir que as especificações de API coletadas pelo Agente de Extração estejam corretas e consistentes. Ele verifica:
def create_validation_agent(self) -> Agent:
return Agent(
role='API Validator',
goal='Validar especificações de API quanto à correção e consistência.',
backstory=dedent("""
Você é um especialista em validação de API, garantindo que todas as especificações
atendam aos padrões e formatos necessários.
"""),
allow_delegation=False,
llm=self.llm
)
def validate_api_spec(self, extracted_data: Dict) -> Task:
return Task(
description=dedent(f"""
Valide a seguinte especificação de API:
{json.dumps(extracted_data, indent=2)}
Verifique:
1. Formato de host válido
2. Endpoint começando com '/'
3. Métodos HTTP válidos (GET, POST, PUT, DELETE, PATCH)
4. Número de porta válido (se fornecido)
5. Presença de modelo JSON para métodos aplicáveis.
Retorne os resultados da validação em formato JSON.
"""),
expected_output="""Um objeto JSON contendo os resultados da validação com quaisquer erros ou confirmação de validade""",
agent=self.validation_agent
)
Avançando, conhecemos o Agente de Interação, nosso Especialista em Interação com o Usuário. Seu papel é obter quaisquer campos de especificação de API ausentes que foram marcados pelo Agente de Extração e validá-los com base nas descobertas do Agente de Validação. Eles interagem diretamente com os usuários para preencher quaisquer lacunas.
Precisamos de duas informações cruciais para criar a interoperabilidade necessária: namespace e nome da produção. O Agente de Produção interage com os usuários para coletar essas informações, de forma muito semelhante ao Agente de Interação.
Assim que as especificações estiverem prontas, é hora de convertê-las em documentação OpenAPI. O Agente de Transformação de Documentação, um especialista em OpenAPI, cuida disso.
def create_transformation_agent(self) -> Agent:
return Agent(
role='Especialista em Transformação OpenAPI',
goal='Converter especificações de API em documentação OpenAPI',
backstory=dedent("""
Você é um especialista em especificações e documentação OpenAPI.
Seu papel é transformar detalhes de API validados em documentação
OpenAPI 3.0 precisa e abrangente.
"""),
allow_delegation=False,
llm=self.llm
)
def transform_to_openapi(self, validated_endpoints: List[Dict], production_info: Dict) -> Task:
return Task(
description=dedent(f"""
Transforme as seguintes especificações de API validadas em documentação OpenAPI 3.0:
Informações de Produção:
{json.dumps(production_info, indent=2)}
Endpoints Validados:
{json.dumps(validated_endpoints, indent=2)}
Requisitos:
1. Gerar especificação OpenAPI 3.0 completa
2. Incluir schemas de requisição/resposta apropriados
3. Documentar todos os parâmetros e corpos de requisição
4. Incluir autenticação se especificado
5. Garantir formatação de caminho apropriada
Retorne a especificação OpenAPI nos formatos JSON e YAML.
"""),
expected_output="""Um objeto JSON contendo a especificação OpenAPI 3.0 completa com todos os endpoints e schemas.""",
agent=self.transformation_agent
)
Após a transformação, a documentação OpenAPI passa por uma revisão meticulosa para garantir conformidade e qualidade. O Agente de Revisão segue esta lista de verificação:
1.Conformidade OpenAPI 3.0
Finalmente, se tudo parecer bom, o Agente de Revisão reporta um objeto JSON saudável com a seguinte estrutura:
{
"is_valid": boolean,
"approved_spec": object (a especificação OpenAPI revisada e possivelmente corrigida),
"issues": [array de strings descrevendo quaisquer problemas encontrados],
"recommendations": [array de sugestões de melhoria]
}
def create_reviewer_agent(self) -> Agent:
return Agent(
role='Revisor de Documentação OpenAPI',
goal='Garantir a conformidade e qualidade da documentação OpenAPI',
backstory=dedent("""
Você é a autoridade final em qualidade e conformidade de documentação OpenAPI.
Com vasta experiência em especificações OpenAPI 3.0, você revisa meticulosamente
a documentação para precisão, completude e adesão aos padrões.
"""),
allow_delegation=True,
llm=self.llm
)
def review_openapi_spec(self, openapi_spec: Dict) -> Task:
return Task(
description=dedent(f"""
Revise a seguinte especificação OpenAPI para conformidade e qualidade:
{json.dumps(openapi_spec, indent=2)}
Lista de Verificação da Revisão::
1. Conformidade OpenAPI 3.0
- Verificar a especificação de versão correta
- Verificar os elementos raiz obrigatórios
- Validar a estrutura do schema
2. Completude
- Todos os endpoints devidamente documentados
- Parâmetros totalmente especificados
- Schemas de requisição/resposta definidos
- Esquemas de segurança configurados corretamente
3. Quality Checks
- Consistent naming conventions
- Clear descriptions
- Proper use of data types
- Meaningful response codes
4. Best Practices
- Proper tag usage
- Consistent parameter naming
- Appropriate security definitions
Você deve retornar um objeto JSON com a seguinte estrutura:
{{
"is_valid": boolean,
"approved_spec": object (a especificação OpenAPI revisada e possivelmente corrigida),
"issues": [array de strings descrevendo quaisquer problemas encontrados],
"recommendations": [array de sugestões de melhoria]
}}
"""),
expected_output=""" Um objeto JSON contendo: is_valid (boolean), approved_spec (object), issues (array), e recommendations (array)""",
agent=self.reviewer_agent
)
O último agente no grupo do planejador é o Agente Iris, que envia a documentação OpenAPI finalizada para o Iris.
def create_iris_i14y_agent(self) -> Agent:
return Agent(
role='Especialista em Integração Iris I14y',
goal='Integrar especificações de API com o serviço Iris I14y',
backstory=dedent("""
Você é responsável por garantir uma integração suave entre o sistema de
documentação da API e o serviço Iris I14y. Você lida com a
comunicação com o Iris, valida as respostas e garante a integração
bem-sucedida das especificações da API.
"""),
allow_delegation=False,
llm=self.llm
)
def send_to_iris(self, openapi_spec: Dict, production_info: Dict, review_result: Dict) -> Task:
return Task(
description=dedent(f"""
Enviar a especificação OpenAPI aprovada para o serviço Iris I14y:
Informações de Produção:
- Nome: {production_info['production_name']}
- Namespace: {production_info['namespace']}
- É Novo: {production_info.get('create_new', False)}
Status da Revisão:
- Aprovado: {review_result['is_valid']}
Retornar o resultado da integração em formato JSON.
"""),
expected_output="""Um objeto JSON contendo o resultado da integração com o serviço Iris I14y, incluindo o status de sucesso e os detalhes da resposta.""",
agent=self.iris_i14y_agent
)
class IrisI14yService:
def __init__(self):
self.logger = logging.getLogger('facilis.IrisI14yService')
self.base_url = os.getenv("FACILIS_URL", "http://dc-facilis-iris-1:52773")
self.headers = {
"Content-Type": "application/json"
}
self.timeout = int(os.getenv("IRIS_TIMEOUT", "504")) # in milliseconds
self.max_retries = int(os.getenv("IRIS_MAX_RETRIES", "3"))
self.logger.info("IrisI14yService initialized")
async def send_to_iris_async(self, payload: Dict) -> Dict:
"""
Enviar carga útil para o endpoint de geração do Iris de forma assíncrona.
"""
self.logger.info("Enviando carga útil para o endpoint de geração do Iris.")
if isinstance(payload, str):
try:
json.loads(payload)
except json.JSONDecodeError:
raise ValueError("Invalid JSON string provided")
retry_count = 0
last_error = None
# Cria timeout para o aiohttp
timeout = aiohttp.ClientTimeout(total=self.timeout / 1000) # Converte ms para seconds
while retry_count < self.max_retries:
try:
self.logger.info(f"Attempt {retry_count + 1}/{self.max_retries}: Enviando requisição para {self.base_url}/facilis/api/generate")
async with aiohttp.ClientSession(timeout=timeout) as session:
async with session.post(
f"{self.base_url}/facilis/api/generate",
json=payload,
headers=self.headers
) as response:
if response.status == 200:
return await response.json()
response.raise_for_status()
except asyncio.TimeoutError as e:
retry_count += 1
last_error = e
error_msg = f"Timeout occurred (attempt {retry_count}/{self.max_retries})"
self.logger.warning(error_msg)
if retry_count < self.max_retries:
wait_time = 2 ** (retry_count - 1)
self.logger.info(f"Waiting {wait_time} seconds before retry...")
await asyncio.sleep(wait_time)
continue
except aiohttp.ClientError as e:
error_msg = f"Failed to send to Iris: {str(e)}"
self.logger.error(error_msg)
raise IrisIntegrationError(error_msg)
error_msg = f"Failed to send to Iris after {self.max_retries} attempts due to timeout"
self.logger.error(error_msg)
raise IrisIntegrationError(error_msg, last_error)
Nosso segundo conjunto de agentes são os Geradores. Eles estão aqui para transformar as especificações OpenAPI em interoperabilidade InterSystems IRIS. Há oito deles neste grupo.
O primeiro deles é o Agente Analisador. Ele é como o planejador, traçando a rota. Seu trabalho é mergulhar nas especificações OpenAPI e descobrir quais componentes de Interoperabilidade IRIS são necessários.
def create_analyzer_agent():
return Agent(
role="Analisador de Especificações OpenAPI",
goal="Analisar minuciosamente as especificações OpenAPI e planejar os componentes de Interoperabilidade IRIS",
backstory="""Você é um especialista em especificações OpenAPI e em Interoperabilidade InterSystems IRIS.
Seu trabalho é analisar documentos OpenAPI e criar um plano detalhado de como eles devem ser implementados como componentes de Interoperabilidade IRIS.""",
verbose=False,
allow_delegation=False,
tools=[analyze_openapi_tool],
llm=get_facilis_llm()
)
analysis_task = Task(
description="""Analisar a especificação OpenAPI e planejar os componentes de Interoperabilidade IRIS necessários.
Incluir uma lista de todos os componentes que devem estar na classe de Produção."",
agent=analyzer,
expected_output="Uma análise detalhada da especificação OpenAPI e um plano para os componentes IRIS, incluindo a lista de componentes de Produção",
input={
"openapi_spec": openApiSpec,
"production_name": "${production_name}"
}
)
Em seguida, os Agentes de Business Services (BS) e Business Operations (BO) assumem o controle. Eles geram os Business Services e as Business Operations com base nos endpoints OpenAPI. Eles usam uma ferramenta útil chamada MessageClassTool para gerar as classes de mensagens perfeitas, garantindo a comunicação.
def create_bs_generator_agent():
return Agent(
role="Gerador de Produção e Business Service IRIS",
goal="Gerar classes de Produção e Business Service IRIS formatadas corretamente a partir de especificações OpenAPI",
backstory="""Você é um desenvolvedor InterSystems IRIS experiente, especializado em Produções de Interoperabilidade.
Sua expertise reside na criação de Business Services e Produções capazes de receber e processar requisições de entrada com base emespecificações de API."",
verbose=False,
allow_delegation=True,
tools=[generate_production_class_tool, generate_business_service_tool],
llm=get_facilis_llm()
)
def create_bo_generator_agent():
return Agent(
role="Gerador de Business Operation IRIS",
goal="Gerar classes de Business Operation IRIS formatadas corretamente a partir de especificações OpenAPI",
backstory="""Você é um desenvolvedor InterSystems IRIS experiente, especializado em Produções de Interoperabilidade.
Sua expertise reside na criação de Business Operations capazes de enviar requisições para sistemas externos com base em especificações de API.""",
verbose=False,
allow_delegation=True,
tools=[generate_business_operation_tool, generate_message_class_tool],
llm=get_facilis_llm()
)
bs_generation_task = Task(
description="Gerar classes de Business Service com base nos endpoints OpenAPI",
agent=bs_generator,
expected_output="Definições de classes de Business Service do IRIS",
context=[analysis_task]
)
bo_generation_task = Task(
description="Gerar classes de Business Operation com base nos endpoints OpenAPI",
agent=bo_generator,
expected_output="Definições de classes de Business Operation do IRIS",
context=[analysis_task]
)
class GenerateMessageClassTool(BaseTool):
name: str = "generate_message_class"
description: str = "Gerar uma classe de Mensagem IRIS"
input_schema: Type[BaseModel] = GenerateMessageClassToolInput
def _run(self, message_name: str, schema_info: Union[str, Dict[str, Any]]) -> str:
writer = IRISClassWriter()
try:
if isinstance(schema_info, str):
try:
schema_dict = json.loads(schema_info)
except json.JSONDecodeError:
return "Error: Invalid JSON format for schema info"
else:
schema_dict = schema_info
class_content = writer.write_message_class(message_name, schema_dict)
# Armazenar a classe gerada.
writer.generated_classes[f"MSG.{message_name}"] = class_content
return class_content
except Exception as e:
return f"Error generating message class: {str(e)}"
Depois que BS e BO fazem o que têm que fazer, é a hora do Agente de Produção brilhar! Este agente junta tudo para criar um ambiente de produção coeso.
Depois que tudo estiver configurado, o próximo na linha é o Agente de Validação. Este entra em cena para uma verificação final, garantindo que cada classe Iris esteja ok.
Em seguida, temos o Agente de Exportação e o Agente de Coleção. O Agente de Exportação gera os arquivos .cls, enquanto o Agente de Coleção reúne todos os nomes de arquivos. Tudo é passado para o importador, que compila tudo no InterSystems Iris.
def create_exporter_agent():
return Agent(
role="Exportador de Classes IRIS",
goal="Exportar e validar definições de classes IRIS para arquivos .cls adequados",
backstory="""Você é um especialista em implantação InterSystems IRIS. Seu trabalho é garantir que as definições de classes IRIS geradas sejam devidamente exportadas como arquivos .cls válidos que
possam ser importados diretamente para um ambiente IRIS.""",
verbose=False,
allow_delegation=False,
tools=[export_iris_classes_tool, validate_iris_classes_tool],
llm=get_facilis_llm()
)
def create_collector_agent():
return Agent(
role="Coletor de Classes IRIS",
goal="Coletar todos os arquivos de classes IRIS gerados em uma coleção JSON",
backstory="""Você é um especialista em sistema de arquivos responsável por reunir e
organizar os arquivos de classes IRIS gerados em uma coleção estruturada.""",
verbose=False,
allow_delegation=False,
tools=[CollectGeneratedFilesTool()],
llm=get_facilis_llm()
)
export_task = Task(
description="Exportar todas as classes IRIS geradas como arquivos .cls válidos",
agent=exporter,
expected_output="Arquivos .cls IRIS válidos salvos no diretório de saída",
context=[bs_generation_task, bo_generation_task],
input={
"output_dir": "/home/irisowner/dev/output/iris_classes" # Optional
}
)
collection_task = Task(
description="Coletar todos os arquivos de classes IRIS gerados em uma coleção JSON",
agent=collector,
expected_output="Coleção JSON de todos os arquivos .cls gerados",
context=[export_task, validate_task],
input={
"directory": "./output/iris_classes"
}
)
Nosso projeto começou como um experimento empolgante, onde meus colegas mosqueteiros e eu almejávamos criar uma ferramenta totalmente automatizada usando agentes. Foi uma jornada selvagem! Nosso foco principal estava em integrações de API REST. É sempre uma alegria receber uma tarefa com uma especificação OpenAPI para integrar; no entanto, sistemas legados podem ser uma história completamente diferente. Pensamos que automatizar essas tarefas poderia ser incrivelmente útil. Mas toda aventura tem suas reviravoltas: Um dos maiores desafios foi instruir a IA a converter OpenAPI para Interoperabilidade Iris. Começamos com o modelo openAI GPT3.5-turbo, que em testes iniciais se mostrou difícil com depuração e prevenção de interrupções. A mudança para o Anthropic Claude 3.7 Sonnet mostrou melhores resultados para o grupo Gerador, mas não tanto para os Planejadores... Isso nos levou a dividir nossas configurações de ambiente, usando diferentes provedores de LLM para flexibilidade. Usamos GPT3.5-turbo para planejamento e Claude sonnet para geração, uma ótima combinação! Essa combinação funcionou bem, mas encontramos problemas com alucinações. A mudança para o GT4o melhorou os resultados, mas ainda enfrentamos alucinações na criação de classes Iris e, às vezes, especificações OpenAPI desnecessárias, como o renomado exemplo Pet Store OpenAPI. Nos divertimos muito aprendendo ao longo do caminho, e estou super animado com o futuro incrível nesta área, com inúmeras possibilidades!
E se você pudesse conversar em um chat para verificar o que acontece na Interoperabilidade, se há algum erro e até mesmo resolver alguns tipos de problemas?
Com o servidor MCP, você pode conectar qualquer um de seus Clientes MCP por exemplo, Claude, ao IRIS e pedir para verificar a Interoperabilidade.
.png)
No artigo anterior, apresentamos o aplicativo d[IA]gnosis, desenvolvido para auxiliar na codificação de diagnósticos na CID-10. Neste artigo, veremos como o InterSystems IRIS for Health nos fornece as ferramentas necessárias para a geração de vetores a partir da lista de códigos da CID-10, usando um modelo de linguagem pré-treinado, seu armazenamento e a subsequente busca por similaridades em todos esses vetores gerados.
Olá, colegas!
Como vocês podem ver, o novo tópico do concurso de programação é Agentes de IA.
O tópico tem sido muito comentado recentemente na Internet e possui diferentes significados. Vocês podem estar curiosos sobre o que queremos dizer com agentes de IA em relação ao concurso de programação da InterSystems.
A InterSystems está na vanguarda da tecnologia de bancos de dados desde sua criação, sendo pioneira em inovações que consistentemente superam concorrentes como Oracle, IBM e Microsoft. Ao se concentrar em um design de kernel eficiente e adotar uma abordagem intransigente em relação ao desempenho de dados, a InterSystems criou um nicho em aplicações de missão crítica, garantindo confiabilidade, velocidade e escalabilidade.
A História de Excelência Técnica
Olá Comunidade!
Confira o novo vídeo dedicado à Gen AI em nosso InterSystems Developers YouTube:
Continuamos com esta série de artigos sobre LLMs e aplicações RAG e neste artigo discutiremos a parte da caixa vermelha do seguinte diagrama:
No processo de criação de uma aplicação RAG, escolher um modelo LLM adequado às suas necessidades (treinado no assunto correspondente, custos, velocidade, etc.) é tão importante quanto ter um claro entendimento do contexto que você deseja fornecer. Vamos começar definindo o termo para ficarmos claros sobre o que entendemos por contexto.
Olá, Comunidade!
Você está usando ferramentas de IA generativa para desenvolvimento? Deixe que os princípios da InterSystems sejam a sua estrela-guia! 🌟
Are you using generative AI tools for development? Let InterSystems principles be your guiding star! 🌟 Saiba mais sobre a abordagem da empresa:
Olá, Comunidade!
Precisa aprender a escrever melhores prompts para GenAI? Este vídeo do Learning Services apresenta seis estratégias principais:
Olá, Comunidade!
Você acha que a IA Generativa pode tornar sua vida mais fácil? Veja alguns casos de uso em potencial para GenAI no vídeo mais recente do Learning Services:
Olá Comunidade!
Como você pode criar uma abordagem equilibrada para usar Generative AI? Obtenha ajuda de especialistas da InterSystems no vídeo mais recente da Learning Services:
Olá, Comunidade!
Você está construindo aplicações de IA generativa? Veja como a arquitetura de Geração Aumentada de Recuperação (RAG) pode ajudar:
Olá, Comunidade!
Como você pode preparar seus dados para aplicações de IA generativas? Obtenha algumas dicas importantes de um especialista da InterSystems:
Olá Comunidade!
Como vocês devem saber, nossa IA da Comunidade de Desenvolvedores já está disponível há mais de um mês 🎉 Esperamos que você tenha ficado curioso o suficiente para experimentar 😁 Se ainda não experimentou, experimente! De qualquer forma, como ainda está em beta, estamos muito interessados em saber o que você pensa sobre ele, e estamos ansiosos para ouvir seus pensamentos e experiências.
Como valorizamos seu tempo e esforço, daremos um prêmio fofo a um membro aleatório da Comunidade que compartilhar como a DC AI ajudou você. Para participar deste sorteio, você precisa seguir as diretrizes:
Com a introdução dos tipos de dados vetoriais e da funcionalidade de Vector Search em IRIS, se abre todo um mundo de possibilidades para o desenvolvimento de aplicações para nós, e um exemplo delas é a que vi recentemente publicada num concurso do Conselho de Saúde de Valencia, onde solicitavam uma ferramenta para ajudar na codificação CID-10 utilizando modelos de IA.
Como poderíamos implementar uma aplicação similar à solicitada? Vejamos o que seria necessário:
Olá Comunidade,
Assista a este vídeo para saber mais sobre a tecnologia de inteligência artificial PainChek, que avalia a dor do paciente na cabeceira do hospital, aproveita a interoperabilidade do InterSystems IRIS para se conectar a sistemas de registros médicos eletrônicos de terceiros:
⏯ Usando Inteligência Artificial/Aprendizado de Máquina para Avaliação da Dor em um Ambiente Clínico @ Global Summit 2023
Olá Comunidade!
Precisa de uma introdução à Generative AI? O Learning Services tem o prazer de anunciar o primeiro vídeo de uma nova série sobre os fundamentos da GenAI:
Quer começar com IA generativa? Experimente dois novos caminhos de aprendizagem. Em Introdução à IA Generativa (2h 45m), aprenda os conceitos básicos de interação com GenAI. Em seguida, experimente Desenvolvendo Aplicativos de IA Generativa (2h) para começar a desenvolver seu próprio aplicativo GenAI. Além disso, ganhe emblemas por concluir cada caminho!
Olá Comunidade,
Esse é um passo a passo detalhado e claro sobre a plataforma IRIS AI Studio. Eu penso alto enquanto tento diferentes exemplos, alguns dos quais falham em devolver os resultados esperados - o que eu acho que é uma necessidade para que um plataforma desse tipo explore diferentes modelos, configurações e limitações. Esse vídeo será útil se está interessado em como construir o "Chat with PDF" (conversa com PDF) ou sistema de recomendações de dados usando a IRIS DB (DataBase - base de dados) e modelos LLM (Large Language Model - grande modelo de lingugagem).
No artigo anterior, vimos detalhes a respeito dos conectores, que permitem que o usuário carregue o arquivo, o converta para incorporações e armazene na IRIS DB. Nesse artigo, vamos explorar opções diferentes de recuperações que o Studio IRIS AI oferece: Semantic Search (pesquisa semântica), Chat (conversa), Recommender (recomendação) e Similarity (similaridade).
Olá Comunidade,
Aqui vai um simples passo a passo sobre as capacidades da plataforma Studio IRIS AI. Ele cobre um fluxo completo de carregar dados no IRIS DB como incorporações de vetor e recuperação de informações usando 4 canais diferentes (pesquisa, conversa, recomendação e similaridade). No último lançamento, adicionei suporte para docker para instalações locais e uma versão ao vivo para explorar.