A tag do concurso reúne postagens relacionadas a qualquer competição de codificação ocorrendo no InterSystems Developer Community.
Olá Desenvolvedores,
Estamos alegres em anunciar o novo concurso online de programação da InterSystems:
🏆 Concurso InterSystems .Net, Java, Python e JavaScript 🏆
Duração: Setembro 22 - Outubro12, 2025
Premiação total: $12.000
(2).jpg)
Usuários do framework %UnitTest agora podem obter informações de cobertura de teste dentro do VS Code combinando a versão mais recente (v2.0.0) da extensão InterSystems Testing Manager com a impressionante Test Coverage Tool de @Timothy.Leavitt.
Acima, você pode ver o painel Cobertura de Teste, que movi para a barra lateral secundária à direita para que possa ser explorado mais facilmente em conjunto com o Explorador de Testes à esquerda.
Se você gostou do que viu, por favor apoie esta ferramenta no Developer Tools 2025 contest. A votação se encerra à meia-noite (EDT) no domingo, dia 3.
Se você já viu um artesão em ação — seja um ceramista moldando o barro até virar arte ou um luthier transformando madeira bruta em um violão extraordinário — sabe que a mágica não está nos materiais, e sim no cuidado, na técnica e no processo. Tenho uma guitarra feita por um luthier que me inspira todos os dias. Mas, vou confessar, criar algo assim é um talento que não tenho.
Por outro lado, no digital, vejo muita gente esperando essa mesma “mágica” de uma IA generativa... prompts genéricos como “crie um app” e esperando resultados espetaculares. Espera-se que a IA faça milagres com zero contexto.
Foi dessa frustração que nasceu o dc-artisan — uma ferramenta para quem quer ser um verdadeiro artesão na criação de prompts. A proposta? Ajudar qualquer pessoa a transformar aquela ideia bruta e mal formata em um prompt funcional, eficiente e cheio de contexto.
Assim como o artesão não faz belas peças por sorte, gerar bons resultados com IA exige intenção, preparo e um bom processo. O problema quase nunca é a IA em si — é como nós a utilizamos. Igual ao luthier que escolhe a madeira certa e molda cada detalhe, engenhar prompts bons exige clareza, estrutura e propósito.
Acreditamos que o mundo merece muito mais do que “prompts mágicos” que só levem à decepção. A IA generativa mostra todo seu potencial guiada por humanos com clareza, objetivos reais e estrutura bem pensada. Nenhum artesão cria beleza por acidente — gerar boas respostas com IA requer preparo e cuidado.
O dc-artisan trata a criação de prompts como um ofício — algo sistematizado, que pode ser aprendido, testado e aprimorado. Ele oferece uma caixa de ferramentas completa, indo além da tentativa-e-erro.
De início, o dc-artisan busca entender seu prompt, ele interage diretamente com você:
Essas interações te ajudam a entender não apenas o “o que” você quer dizer, mas o “por quê”.
Com o objetivo claro, o dc-artisan analisa a estrutura do seu prompt e oferece sugestões personalizadas — para melhorar a clareza, ajustar o tom e preencher lacunas críticas de contexto.
E o melhor: tudo isso dentro do editor favorito — o VS Code! Você pode incluir variáveis diretamente no seu prompt (como {task} ou {audience}), o que oferece flexibilidade e reaproveitamento. É possível visualizar instantaneamente como os prompts ficam com diferentes substituições — e ver exatamente como vão funcionar.
Mas não para por aí.
O dc-artisan também ajuda você a fazer tuning de prompts para extrair o melhor desempenho. Basta fazer o upload de um CSV com casos de teste para que a ferramenta avalie de forma automatizada a consistência, a qualidade da saída e o impacto da estrutura do prompt em diferentes contextos.
O dc-artisan analisa cada resposta e gera um relatório completo com métricas de similaridade — assim você pode otimizar seus prompts com dados reais, não com achismo.
Criar prompts sem estrutura é como tentar esculpir madeira vendado. Algo pode sair... mas dificilmente vai soar como um bom instrumento.
Muitos caem em dois extremos: prompts vagos e curtos demais, ou blocos enormes de conteúdo jogados sem organização. Nenhum dos dois funciona. Ou a IA não entende o que você quer, ou se perde em um mar de informações inúteis.
E quando o contexto é longo ou confuso demais, até LLMs avançadas perdem o rumo. Em vez de pensar, elas repetem o conteúdo anterior ou se prendem a padrões do início da conversa. Ironicamente, modelos com contexto grandes (como 32k tokens) são ainda mais propensos a este erro.
A solução para esse problema? RAG (Retrieval-Augmented Generation): não dar qualquer informação à IA, mas sim as relevantes, no momento certo.
O dc-artisan une criação de prompts com gestão de contexto. Ele não só te ajuda a escrever prompts melhores — ele garante que a IA receba informação relevante, e não um tsunami aleatório.
Com o Modo RAG Pipeline, você pode:
Essa ideia foi inspirada pelo Portal de Ideias da InterSystems (DPI-I-557)
Um dos maiores diferenciais do dc-artisan está por trás dos panos: seu backend. A extensão roda sobre o InterSystems IRIS Interoperability, com um adapter para o liteLLM que desenvolvemos.
Essa estrutura garante flexibilidade e integração com múltiplas LLMs. Você não fica preso a uma única IA. Pode alternar e conectar, no mesmo ambiente, com plataformas como OpenAI, Gemini, Claude, Azure OpenAI entre outras.
Cada vez mais desenvolvedores estão percebendo que prompting não é sobre “mágica” — é sobre propósito, clareza e contexto. Não se trata de chutar palavras certas, mas projetar prompts como engenheiros e não como feiticeiros.
Assim como luthiers criam instrumentos com alma a partir de madeira, você também pode esculpir prompts com contexto, previsíveis e eficazes com uma ferramenta feita sob medida para isso.
dc-artisan não é só uma ferramenta — é uma mudança de mentalidade: do improviso para a precisão, da sorte para a técnica, da intuição para a arte.
🎸 Pronto pra criar prompts com as próprias mãos?
⚙️ Abra o VS Code, instale o dc-artisan e comece a esculpir seu prompt como um artesão — não como um mágico.
Olá,
Neste artigo vamos ver o uso do python como linguagem de programação no InterSystems Iris. Para tal vamos usar como referência a versão Community 2025.1 que está disponível para ser baixada em https://download.intersystems.com mediante o login no ambiente. Para maiores informações sobre o download e instalação do Iris veja o link da comunidade https://community.intersystems.com/post/how-download-and-install-intersystems-iris
Apresento o FHIRCraft, uma ferramenta leve para gerar recursos FHIR sintéticos.
Talvez vocês estejam pensando:
“Mas... já não existe o Synthea, que gera um monte de recursos FHIR?”
Exatamente — e foi justamente por isso que criei este aplicativo.
O FHIRCraft foi desenvolvido para gerar recursos FHIR mais simples, pequenos e focados. Diferente do Synthea, ele não pretende simular prontuários clínicos completos nem fluxos assistenciais. É pensado para quem está começando com FHIR, quer fazer testes de forma progressiva ou explorar como funciona um recurso específico de forma isolada.
Assim como um nocaute, sem dar chances ao adversário, o Kubernetes, enquanto uma plataforma de código aberto, tem um universo de oportunidades devido à sua disponibilidade (isto é, a facilidade para encontrar suporte, serviços e ferramentas). Ele é uma plataforma que pode gerenciar os trabalhos e serviços em contêineres, o que simplifica e muito a configuração e automação destes processos.
Mas, vamos justificar a imagem título e dar o nome “correto” à ferramenta em questão: InterSystems Kubernetes Operator.
O princípio é básico, escolhem-se os serviços e
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!
Ao contrário do filme, citado através da imagem (para quem não conhece, Matrix, 1999), a escolha entre Dynamic SQL e Embededd SQL, não é uma escolha entre a verdade e a fantasia, mas, mesmo assim é uma decisão a ser tomada. Abaixo, tentarei facilitar a escolha de vocês.
API REST com Swagger no InterSystems IRIS
Olá,
O protocolo HTTP permite a obtenção de recursos, como documentos HTML. É a base de qualquer troca de dados na Web e um protocolo cliente-servidor, o que significa que as requisições são iniciadas pelo destinatário, geralmente um navegador da Web.
As API REST se beneficiam deste protocolo para trocar mensagens entre cliente e servidor. Isso torna as APIs REST rápidas, leves e flexíveis. As API REST utilizam os verbos HTTP GET, POST, PUT, DELETE e outros para indicar as ações que desejam realizar.
HTTP e HTTPS com API REST
Olá,
O protocolo HTTP permite a obtenção de recursos, como documentos HTML. É a base de qualquer troca de dados na Web e um protocolo cliente-servidor, o que significa que as requisições são iniciadas pelo destinatário, geralmente um navegador da Web.
As API REST se beneficiam deste protocolo para trocar mensagens entre cliente e servidor. Isso torna as APIs REST rápidas, leves e flexíveis. As API REST utilizam os verbos HTTP GET, POST, PUT, DELETE e outros para indicar as ações que desejam realizar.
Utilizando Flask, API REST e IAM com o InterSystems IRIS
Parte 3 – IAM
O InterSystems API Manager (IAM) é um componente que permite monitorar, controlar e gerir o tráfego de APIs baseadas em HTTP. Ele também atua como uma API gateway entre aplicações e servidores InterSystems IRIS.
O documento publicado em https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=PAGE_apimgr traz as informações sobre o produto.
Utilizando Flask, API REST e IAM com o InterSystems IRIS
Parte 2 – Aplicativo Flask
Flask é um microframework de desenvolvimento web escrito em Python. Ele é conhecido por ser simples, flexível e permitir o desenvolvimento rápido de aplicações.
A instalação do Flask é muito simples. Depois de ter o python instalado corretamente no seu sistema operacional precisamos instalar a biblioteca flask com o comando pip. Para o consumo de API REST é aconselhado o uso da biblioteca requests. O link a seguir traz um guia para a instalação do flask: https://flask.palletsprojects.com/en/stable/installation/
Utilizando Flask, API REST e IAM com o InterSystems IRIS
Parte 1 – API REST
Olá,
Neste artigo vamos ver a implementação de uma API REST para realizar a manutenção de um CRUD, utilizando o Flask e o IAM.
Nesta primeira parte do artigo vamos ver a construção e publicação da API REST no Iris.
Primeiro, vamos criar a nossa classe persistente para armazenar os dados. Para isso vamos para o Iris e criamos nossa classe:
Class ERP.Cliente Extends (%Persistent, %Populate, %XML.Adaptor)
{
Property nome As %String;
Property idade As %Integer;
}
Utilizando o Gateway SQL com Python, Vector Search e Interoperabilidade no InterSystems Iris
Parte 3 – REST e Interoperabilidade
Utilizando o Gateway SQL com Python, Vector Search e Interoperabilidade no InterSystems Iris
Parte 2 – Python e Vector Search
Uma vez que temos acesso aos dados da nossa tabela externa podemos utilizar tudo que o Iris tem de excelente com estes dados. Vamos, por exemplo, ler os dados da nossa tabela externa e gerar uma regressão polinomial com eles.
Para mais informações sobre o uso do python com o Iris veja a documentação disponível em https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=AFL_epython
Utilizando o Gateway SQL com Python, Vector Search e Interoperabilidade no InterSystems Iris
Parte 1 – Gateway SQL
Olá,
Neste artigo vamos ver o uso do Gateway SQL no Iris. O Gateway SQL permite que o Iris tenha acesso a tabelas de outros bancos (externos) via ODBC ou JDBC. Podemos acessar Tabelas ou Visões de diversos bancos, como Oracle, PostgreSQL, SQL Server, MySQL e outros.
Do ponto de vista de uso é como se a tabela estivesse local na nossa instância Iris, porém o armazenamento é realizado em um local externo.
| “A pedido dos sobreviventes, os nomes foram alterados. Por respeito aos mortos, o RESTO foi contado exatamente como aconteceu.” |
Olá Comunidade!
Realizaremos um Webinar com os vencedores do Concurso de Tutoriais Técnicos InterSystems IRIS da Comunidade de Desenvolvedores PT.
Teremos a oportunidade de conhecer um pouquinho mais os membros vencedores do concurso que contribuíram, e continuam colaborando, com ótimos tutoriais e conteúdos para a nossa Comunidade.
A classificação foi:
🥇 1º lugar: Utilizando IRIS - Vector Search - Estudo de Caso: Recomendação de Filmes por @Davi Massaru Teixeira Muta
🥈 2º lugar: Usando o FHIR SQL Builder por @Yuri Marx
Olá Comunidade!
É com imensa satisfação que anunciamos os vencedores do ✍️ Concurso de Tutoriais Técnicos InterSystems IRIS ✍️.
Agradecemos a todos os participantes por seu empenho e contribuição à nossa comunidade. Temos ótimos novos artigos tutoriais para ler e reproduzir, e assim enriquecer nosso conhecimento e habilidades de desenvolvimento na tecnologia InterSystems IRIS.
Vencedores da Premiação de Especialista
🥇 1º lugar: Utilizando IRIS - Vector Search - Estudo de Caso: Recomendação de Filmes por @Davi Massaru Teixeira Muta
🥈 2º lugar: Usando o FHIR SQL Builder por @Yuri Marx
Olá Comunidade!
Está aberto para os membros da Comunidade de Desenvolvedores o Período de Votação do Concurso de Tutoriais, que vai de 25 de novembro a 01 de dezembro. O artigo com o maior número de curtidas irá receber o prêmio da Comunidade de Desenvolvedores: 🎁 Echo Dot - Alexa Echo Dot 5ª Geração
Aproveite os excelentes tutoriais participantes e ajude a premiar o tutorial que você mais gostar com a sua curtida.
Participe!
Olá Comunidade!
Estamos a poucos dias da finalização do período para participação no ✍️ Concurso de Tutoriais Técnicos InterSystems IRIS ✍️.
Envie o seu artigo tutorial até 24 de novembro e participe!
Ainda há tempo de finalizar o seu tutorial para participar e concorrer aos prêmios.
Esperamos por ótimos tutoriais!
Boa sorte a todos 🍀😉
Olá Comunidade!
Para você que não conseguiu finalizar o seu tutorial ou aos que pretendem concorrer com mais de um tutorial, temos uma grande surpresa.
Estamos estendendo o prazo do nosso concurso até o dia 24 de Novembro!
Isso mesmo! Agora você não tem mais desculpa de ficar de fora.
Participe do nosso último concurso de 2024, e concorra aos super prêmios enquanto compartilha conhecimento com a Comunidade de Desenvolvedores.
Esperamos por ótimos tutoriais! 😃
Olá Desenvolvedores!
Tenho o prazer de anunciar que hoje inicia o novo concurso da nossa Comunidade de Desenvolvedores InterSystems.
Aproveite a chance de se aprimorar e compartilhar aprendizados com a Comunidade de Desenvolvedores, e concorrer a prêmios excelentes.
Todas as informações e regras estão publicadas no anúncio ✍️ Concurso de Tutoriais Técnicos InterSystems IRIS ✍️
Participe e compartilhe! 😉
Olá, Comunidade!
É hora do próximo concurso da Comunidade de Desenvolvedores InterSystems!
✍️ Concurso de Tutoriais Técnicos InterSystems IRIS ✍️
Crie um Tutorial** Técnico que possa ser considerado um guia para programadores de InterSystems IRIS de qualquer nível: iniciante/intermediário/sênior, de 14 de outubro a 24 de novembro. O tutorial pode ser no formato de Artigo com textos e imagens e/ou Vídeo demonstrativo.
Aproveite e deixe a sua criatividade fluir! Mostre o quanto pode ser fácil e divertido criar soluções com o InterSystems IRIS.
🎁Prêmios para todos: Um prêmio especial para cada autor participante do concurso!
Desenvolvimento de frontend pode ser uma tarefa muito difícil, especialmente para desenvolvedores focados em backend. Mais cedo na minha carreira, as linhas entre frontend e backend eram borradas, e se experava de todos que conseguissem manejar ambos. CSS em particular era um desafio constante, parecia uma missão impossível.
Apesar de eu aproveitar trabalho de frontend, CSS ainda é um desafio complexo para mim, especialmente porque aprendi por tentativa e erro. O meme do Peter Griffin com dificuldade para abrir persianas captura perfeitamente minha experiência aprendendo CSS
Porém, hoje, tudo vai mudar. Ferramentas como o Streamlit revolucionaram o jogo para desenvolvedores como eu, que preferem o conforto de uma tela preta do terminal. Foram-se os dias de luta com linhas de código que parecem mensagens criptografadas de alienígenas (estou olhando para você, CSS!). Como o Doctor Károly Zsolnai-Fehér, de Two Minute Papers, sempre diz, "que momento para estar vivo!". Com Streamlit, você pode construir uma aplicação web inteira somente usando código Python. Quer ver isso em ação? Prepare-se, porque eu estou prestes a mostrar minha tentativa de criar um frontend para o SQLZilla com essa ferramenta incrível.
Para instalar, simplesmente abra seu terminal e lance esse feitiço:
pip install streamlit
(Ou você pode adicionar isso no seu arquivo requirements.txt.)
Crie um arquivo, app.py e adicione esse code snippet para exibir um tíitulo "SQLZilla":
import streamlit as st
st.title("SQLZilla")
Rode o Show!
Abra seu terminal de novo e digite este comando para ativar sua criação:
streamlit run app.py
Voila!Seu app Streamlit deve aparecer no seu browser, orgulhosamente exibindo o título "SQLZilla."
Adicione um a imagem usando o método image. Para centralizá-la eu só criei 3 colunas e adicionei ela no centro (que vergonha!)
st.title("SQLZilla")
left_co, cent_co, last_co = st.columns(3)
with cent_co:
st.image("small_logo.png", use_column_width=True)
Para administrar configurações e resultados de queries, você pode usar session_state. Aqui está uma forma de salvar os valores de configuração e guardar resultados de queries:
if 'hostname' not in st.session_state:
st.session_state.hostname = 'sqlzilla-iris-1'
if 'user' not in st.session_state:
st.session_state.user = '_system'
if 'pwd' not in st.session_state:
st.session_state.pwd = 'SYS'
# Add other session states as needed
Para conectar o SQLZilla a uma base de dados InterSystems, você pode usar SQLAlchemy. Primeiro, instale SQLAlchemy com:
pip install sqlalchemy
Então, configure a conexão no seu arquivo app.py:
from sqlalchemy import create_engine
import pandas as pd
# Substitua com os detalhes da sua conexão
engine = create_engine(f"iris://{user}:{password}@{host}:{port}/{namespace}")
def run_query(query):
with engine.connect() as connection:
result = pd.read_sql(query, connection)
return result
Uma vez conectado na base de dados, você pode usar Pandas e Streamlit para exibir os resultados de suas queries. Aqui está um exemplo de como exibir um DataFrame no seu app Streamlit:
if 'query' in st.session_state:
query = st.session_state.query
df = run_query(query)
st.dataframe(df)
Para deixar seu app mais interativo, você pode usar st.rerun()para atualizar o aplicativo sempre que a query mudar:
if 'query' in st.session_state and st.button('Run Query'):
df = run_query(st.session_state.query)
st.dataframe(df)
st.rerun()
VocÇe pode encontrar vários componentes Streamlit para usar. No SQLZilla, eu adicionei o editor de código ACE na versão chamada streamlit-code-editor:
from code_editor import code_editor
editor_dict = code_editor(st.session_state.code_text, lang="sql", height=[10, 100], shortcuts="vscode")
if len(editor_dict['text']) != 0:
st.session_state.code_text = editor_dict['text']
Já que o assistente SQLZilla é escrito em Python, eu só chamei a classe:
from sqlzilla import SQLZilla
def assistant_interaction(sqlzilla, prompt):
response = sqlzilla.prompt(prompt)
st.session_state.chat_history.append({"role": "user", "content": prompt})
st.session_state.chat_history.append({"role": "assistant", "content": response})
if "SELECT" in response.upper():
st.session_state.query = response
return response
Parabéns! Você construiu seu próprio SQLZilla. Continue explorando o Streamlit e melhore seu app com mais recursos. E se gostar do SQLZilla, vote por esse assistente incrível que converte seus textos em queries!
Olá Comunidade,
É hora de anunciar os vencedores do Concurso de Python!
Obrigada a todos os nossos maravilhosos participantes que submeteram 9 aplicações 🔥
(2).jpg)
Olá Comunidade,
Nesse artigo, demonstrarei os seguintes passos para criar seu próprio chatbot utilizando spaCy (spaCy é uma biblioteca de software de código aberto para o processamento avançado de linguagem natural, escrita nas linguagens de programação Python e Cython):
Comecemos
Oi Comunidade,
Estamos felizes em convidar vocês para a próxima competição online de programação da InterSystems, que será focada em Python!
🏆 Competição InterSystems Python 🏆
Duração: Julho 15 - Agosto 4, 2024
Premiação total: $14,000
.jpg)
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).