New post

Encontrar

Article
· 5 hr ago 4m read

Usando Auditoria Python para depuração de Embedded Python

#Embedded Python #InterSystems IRIS

A PEP 578 adicionou hooks de auditoria ao Python. Uma grande variedade de eventos (carregamento de módulos, interações com o sistema operacional e assim por diante) aciona eventos de auditoria aos quais você pode se inscrever.

Veja como fazer isso. Primeiro, crie um hook de Python embutido (embedded python hook):

Class User.Python {

/// do ##class(User.Python).Audit() 
ClassMethod Audit() [ Language = python ] 
{ 
    import sys 
    import time
    
    def logger(event,args):      
        if event=='import':         
        module = args[0]         
        print(f"Carregando {module}")         
        if module == "numpy":             
            print(f"Módulo {module} proibido. Encerrando processo em 3.")             
            time.sleep(3)             
            sys.exit(0)      
        elif event in ('compile','exec'):         
            print(f"{event}: {args}")      
        elif event in ('code.new','open'):         
            # não faz nada para este evento         
            x=1      
        else:         
            print(f"{event}")

sys.addaudithook(logger) }

}

Neste exemplo, nós:

  • Encerramos o processo se o numpy começar a ser carregado
  • Exibimos o evento e os argumentos para eventos compile/exec
  • Ignoramos eventos de code
  • Registramos todos os outros eventos

Tudo isso será gravado no STDOUT padrão.

Para começar a auditar, basta chamar este método para registrar seu hook, ou você pode até mesmo fazer isso automaticamente no início do job:

%ZSTART JOB     
new $namespace     
set $namespace = "%SYS"     
do ##class(User.Python).Audit()     
quit LOGIN     
do JOB     
quit

Aqui está um exemplo de saída:

%SYS>:PY
Loading code
exec: (<code object <module> at 0x000001AB82A0F2F0, file "c:\intersystems\iris\lib\python\lib\code.py", line 1>,)
Loading traceback
exec: (<code object <module> at 0x000001AB82A173A0, file "c:\intersystems\iris\lib\python\lib\traceback.py", line 1>,)
Loading linecache
exec: (<code object <module> at 0x000001AB82A17A80, file "c:\intersystems\iris\lib\python\lib\linecache.py", line 1>,)
Loading tokenize
exec: (<code object <module> at 0x000001AB82A32030, file "c:\intersystems\iris\lib\python\lib\tokenize.py", line 1>,)
Loading token
exec: (<code object <module> at 0x000001AB82A323A0, file "c:\intersystems\iris\lib\python\lib\token.py", line 1>,)
compile: (b'lambda _cls, type, string, start, end, line: _tuple_new(_cls, (type, string, start, end, line))', '<string>')
exec: (<code object <module> at 0x000001AB82A32710, file "<string>", line 1>,)
sys._getframe
object.__setattr__
Loading codeop
exec: (<code object <module> at 0x000001AB82A32EA0, file "c:\intersystems\iris\lib\python\lib\codeop.py", line 1>,)
Loading __future__
exec: (<code object <module> at 0x000001AB82A472F0, file "c:\intersystems\iris\lib\python\lib\__future__.py", line 1>,)
 
Python 3.9.5 (default, May 31 2022, 12:35:47) [MSC v.1927 64 bit (AMD64)] on win32
Type quit() or Ctrl-D to exit this shell.
compile: (b'import iris', '<input>')
compile: (b'import iris\n', '<input>')
compile: (b'import iris\n\n', '<input>')
exec: (<code object <module> at 0x000001AB82A60870, file "<input>", line 1>,)
>>> import json
compile: (b'import json', '<input>')
compile: (b'import json\n', '<input>')
compile: (b'import json\n\n', '<input>')
exec: (<code object <module> at 0x000001AB82A60870, file "<input>", line 1>,)
Loading json
exec: (<code object <module> at 0x000001AB82A60DF0, file "c:\intersystems\iris\lib\python\lib\json\__init__.py", line 1>,)
Loading json.decoder
os.listdir
exec: (<code object <module> at 0x000001AB82A67710, file "c:\intersystems\iris\lib\python\lib\json\decoder.py", line 1>,)
Loading json.scanner
exec: (<code object <module> at 0x000001AB82A679D0, file "c:\intersystems\iris\lib\python\lib\json\scanner.py", line 1>,)
Loading _json
Loading json.encoder
exec: (<code object <module> at 0x000001AB82A71500, file "c:\intersystems\iris\lib\python\lib\json\encoder.py", line 1>,)
>>> x=1
compile: (b'x=1', '<input>')
compile: (b'x=1\n', '<input>')
compile: (b'x=1\n\n', '<input>')
exec: (<code object <module> at 0x000001AB82A60870, file "<input>", line 1>,)

Acho que isso pode ser muito útil para depuração.

Discussion (0)1
Log in or sign up to continue
Article
· 5 hr ago 7m read

Implantar o IRIS Community Edition na nuvem: Parte 2 Azure

#Azure #Cloud #InterSystems IRIS #InterSystems IRIS for Health

 

Olá! 

No meu último artigo, fiz um passo a passo sobre como você pode tentar implantar o InterSystems IRIS Community Edition, ou IRIS for Health Community Edition, gratuitamente na AWS. Nesta continuação, mostrarei o mesmo para o próximo maior provedor de nuvem, o Microsoft Azure. 

Assim como na AWS, o Azure também oferece uma opção gratuita ao se cadastrar, embora seja um pouco menos generosa - você recebe US$ 200 de crédito gratuito para gastar no primeiro mês. Isso significa que você pode, mais uma vez, tentar implantar o IRIS Community Edition gratuitamente no Azure, embora eu recomende cautela para evitar contas caras. 

Assim como no artigo anterior, este guia percorre o processo de implantação do Community Edition na nuvem, no entanto, o processo pode ser seguido para uma versão totalmente licenciada,  já que existe uma oferta Bring Your Own Licence (Traga Sua Própria Licença) para o IRIS e IRIS for Health. Você pode usar uma chave de licença existente para isso ou entrar em contato com o departamento de vendas para obter uma nova licença. 

Passo a passo

Antes de começar, você precisará entrar ou criar uma conta no Azure e inscrever-se em uma assinatura do Azure (para habilitar o faturamento). Em seguida, vá para a listagem do Azure Marketplace para o IRIS Community (ou IRIS for Health Community) e clique em Get it now (Obter agora). 

 

Será solicitado que você faça login e também podem ser solicitados detalhes adicionais, como País, número de celular e local de trabalho. Preencha esses dados e clique em Get it now na parte inferior deste formulário.

 

Você será redirecionado para o Portal do Azure. Clique em Start with a pre-set configuration (Iniciar com uma configuração predefinida) para começar a criar uma implantação. Se preferir selecionar todas as configurações você mesmo, pode clicar em Create (Criar) para implantar sem nenhuma configuração padrão.

 

Depois de escolher começar com uma configuração predefinida, você será redirecionado para uma página sugerindo padrões para seu caso de uso. Escolha o caso de uso necessário e clique em Continue to Create a VM (Continuar para criar uma VM); essa escolha preencherá automaticamente algumas das configurações.

 

Escolhendo as configurações da VM

Agora você entrará na página Create a virtual machine (Criar uma máquina virtual). É aqui que você define todas as configurações para a implantação da sua máquina virtual.

Existem abas para escolher configurações em "Basics" (Básico), "Disks" (Discos/armazenamento), "Networking" (Rede), "Management" (Gerenciamento), "Monitoring" (Monitoramento), "Advanced Settings" (Avançado) e "Tags". Este guia discutirá as configurações em "Basics". Para as outras configurações, você pode deixá-las como padrão se tiver iniciado com uma configuração predefinida ou selecioná-las no seu próprio tempo. Muitas delas podem ser alteradas após a implantação (por exemplo, limitando os endereços IP de conexão).

Project Details (Detalhes do Projeto) 

Aqui você escolhe qual Assinatura do Azure e Grupo de recursos estão sendo usados para a implantação. Um grupo de recursos permite agrupar implantações relacionadas (por exemplo, implantações para diferentes serviços de um único projeto) para fins de organização e faturamento. Você precisará criar um grupo de recursos se ainda não tiver feito isso. Clique em Create new (Criar novo) e dê um nome adequado.

 

Instance Details (Detalhes da Instância) 

Os detalhes da instância controlam o tamanho, a localização e as configurações de segurança da instância. Como você clicou através do portal do Azure, a imagem deve ter sido preenchida previamente. Caso contrário, você pode selecioná-la através do menu suspenso do marketplace.

Existem vários itens essenciais para preencher nesta seção.

- Virtual Machine Name (Nome da Máquina Virtual) - De preferência, use algo fácil de reconhecer para facilitar o gerenciamento.

- Region (Região) - Quanto mais próxima a região estiver de seus usuários, menor será a latência ao acessar a máquina. No entanto, a escolha da região também afetará a disponibilidade das máquinas.

- Size (Tamanho) - As especificações de desempenho da máquina, incluindo memória e número/tipo de processadores disponíveis (CPUs, GPUs). A escolha do tamanho dependerá do orçamento, desempenho necessário e disponibilidade na região selecionada. Como o próprio InterSystems IRIS Community Edition limita o armazenamento no banco de dados e o poder de computação usado ( veja os limites aqui), você provavelmente desejará uma das máquinas menores.

 

Authentication (Autenticação)

Aqui você pode escolher como se autenticar ao conectar-se à máquina. Sugere-se que você use um par de chaves pública/privada SSH para isso, mas também pode usar autenticação por senha. Você também pode selecionar um nome de usuário padrão para acessar a máquina.

Você pode deixar todas essas configurações como padrão. Se escolher criar uma nova chave SSH, ela será gerada e baixada automaticamente quando você implantar a máquina.

 

Review + Create (Revisar + Criar)

Depois de definir o "Basics", verifique as outras abas de configurações e veja se há algo que você gostaria de alterar dos padrões. Se não, selecione a aba Review + Create.

Esta aba levará um tempo para carregar, pois valida as configurações selecionadas. Após a aprovação da validação, você deve concordar com os Termos pela última vez e também verá um resumo das configurações selecionadas.

Quando estiver pronto, clique em Create (Criar) para criar sua máquina virtual.

 Se você selecionou autenticar com uma nova chave SSH conforme sugerido, aparecerá um pop-up para gerar e baixar isso. Clique em Download private key and create resource (Baixar chave privada e criar recurso).

 

Conectar

Levará alguns minutos para sua implantação ser iniciada, mas você deve acabar em uma tela dizendo "Your deployment is complete" (Sua implantação foi concluída).

 

Existem várias configurações que o Azure recomenda definir, o que você pode desejar fazer em breve. No entanto, para demonstrar inicialmente a conexão com a máquina, clique em Go to resource (Ir para o recurso). Isso abrirá o painel de gerenciamento da sua máquina virtual implantada.

 

No lado esquerdo, há um painel para selecionar diferentes grupos de configurações para visualizar e editar as configurações da máquina. Por enquanto, selecione Connect (Conectar) no painel na parte superior do dashboard.

Via SSH

No Azure, o Secure Shell (SSH) é o método recomendado ao conectar-se à instância do InterSystems IRIS Community Edition. Você pode se conectar via SSH a partir do terminal da sua máquina local ou powershell.

 

No painel de conexão, você verá claramente o endereço IP da sua instância e um comando SSH para usar na conexão com a instância. O comando de conexão SSH requer três coisas: o caminho local para sua chave privada que foi baixada quando você iniciou a instância, o nome de usuário na máquina (o padrão era azureuser a menos que você o tenha alterado na etapa de Autenticação acima) e o endereço IP da sua instância.

ssh -i /caminho/para/chave.pem username@xx.xx.xxx.xxx

ssh -i /home/keys/Minha-Instancia-Iris_key.pem azureuser@12.34.567.899

Na primeira vez que se conectar, será perguntado se você tem certeza de que deseja continuar conectando. Digite "yes" e você se conectará à instância.

 

Na primeira vez que fizer login, você precisará redefinir a senha padrão. Para fazer isso, execute:

iris password

Um aviso informará que as credenciais padrão são:

- Usuário: _SYSTEM

- Senha: SYS

E que essa senha expirou e precisa ser alterada. Se, como eu, você preferir o outro nome de usuário padrão, SuperUser, ele também deve funcionar com a mesma senha.

Depois disso, você pode iniciar uma sessão de terminal IRIS com:

iris session iris

Se você quiser copiar arquivos para a instância IRIS, pode usar uma conexão SSH usando scp, sftp ou um cliente sftp como o Filezilla. Você também pode copiar arquivos através do serviço Bastion do Azure.

Via Portal de Gerenciamento

Uma vez implantado, o Portal de Gerenciamento estará disponível no endereço IP da sua instância com :52773/csp/sys/UtilHome.csp anexado ao final. As credenciais padrão são:

- Usuário: _SYSTEM - Senha: SYS

Elas precisarão ser alteradas no primeiro login, a menos que você já as tenha alterado pela conexão SSH.

Encerrar Implantação

Lembre-se de parar a implantação assim que terminar de usá-la! Para fazer isso, navegue de volta para o painel da Máquina Virtual da sua instância e clique em Delete (Excluir). Você será questionado sobre quais componentes deseja excluir. Se você terminou completamente de usar esta implantação, selecione todos os componentes e clique em Delete para encerrar todas as implantações.

 

Discussion (0)1
Log in or sign up to continue
InterSystems Official
· 6 hr ago

Une troisième version préliminaire pour développeurs d'InterSystems IRIS, d'InterSystems IRIS for Health et de HealthShare Health Connect 2026.1 est disponible

#API #Platforms #Release #InterSystems IRIS #Documentation #Health Connect #InterSystems IRIS for Health #InterSystems Official

Les troisièmes versions préliminaires pour développeurs de la plateforme de données InterSystems IRIS®, d'InterSystems IRIS® for Health et de HealthShare® Health Connect 2026.1 sont disponibles sur le site des versions préliminaires pour développeurs du WRC. Les conteneurs sont disponibles sur notre registre de conteneurs et portent l'étiquette « latest-preview ».

Ces versions préliminaires pour développeurs marquent la fin de la prise en charge des Mac Intel à partir de la version 2026.1.0 et le retour de la prise en charge de Windows Server 2019 dans la version 2026.1.0.

La documentation initiale est accessible via les liens ci-dessous :

Ces liens sont provisoires et seront mis à jour à mesure que nous approcherons de la version finale et que nous aurons plus d'informations à partager. Voici quelques ajouts importants à la documentation de la version 2026.1 :

Comme il s'agit d'une version préliminaire pour développeurs, certains contenus sont encore en cours d'élaboration. La documentation complète sera fournie au fur et à mesure de la finalisation des fonctionnalités. Nous vous remercions de votre patience et de vos commentaires pendant cette phase !

Disponibilité et informations sur les packages

Cette version est fournie avec des packages d'installation classiques pour toutes les plateformes prises en charge. Pour obtenir la liste complète, consultez le document « Plateformes prises en charge ».

Les packages d'installation et les clés d'évaluation sont disponibles sur le site de téléchargement des versions préliminaires du WRC ou sur le site web des services d'évaluation (cochez la case « Afficher les logiciels en version préliminaire »).

Discussion (0)0
Log in or sign up to continue
Digest
· 9 hr ago

【週間ダイジェスト】 2/02 ～ 2/08 の開発者コミュニティへの投稿

#Developer Community Official #Digest
2/02 ～ 2/08Week at a GlanceInterSystems Developer Community
Article
· 9 hr ago 5m read

揭开 LangGraph 的神秘面纱

#Large Language Model (LLM) #Python #Other

如何使用 LangGraph 构建应用程序：分步指南

标签#LangGraph#LangChain#AI#代理#Python#LLM#状态管理#工作流

大家好，我想向大家介绍一下我正在研究和开发的工具 LangGraph。

基本上，传统的人工智能应用程序在处理复杂的工作流和动态状态时经常面临挑战。LangGraph提供了一个强大的解决方案，可以创建有状态的代理，管理复杂的对话，做出基于上下文的决策，并执行复杂的工作流。

本文提供了使用LangGraph 构建应用程序的分步指南，LangGraph 是一个用于创建具有状态图的多步骤代理的框架。

实施步骤：

  1. 设置环境和安装依赖项
  2. 定义应用程序状态
  3. 创建图节点
  4. 配置状态图
  5. 运行代理

1.设置环境并安装依赖项

第一步是设置 Python 环境并安装必要的库：

pip install langgraph langchain langchain-openai

配置 API 凭据：

import os
from langchain_openai import ChatOpenAI

# Configure your API Key
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# Initialize the model
llm = ChatOpenAI(model="gpt-4", temperature=0)

2.定义应用程序状态

LangGraph 使用TypedDict定义图节点之间共享的状态：

from typing import TypedDict, Annotated
from operator import add

class AgentState(TypedDict):
    """State shared between graph nodes"""
    messages: Annotated[list, add]
    user_input: str
    response: str
    next_step: str

该状态存储

  • 消息：交换信息的历史
  • user_input：当前用户输入
  • 响应：由代理生成的响应
  • next_step：下一个要执行的操作

3.创建图形节点

3.1 - 输入处理节点

该节点处理用户输入并准备上下文：

def process_input(state: AgentState) -> AgentState:
    """Processes user input"""
    user_message = state["user_input"]
    
    # Add message to history
    state["messages"].append({
        "role": "user",
        "content": user_message
    })
    
    # Define next step
    state["next_step"] = "analyze"
    
    return state

3.2 - 分析和决策节点

该节点使用 LLM 分析输入并决定下一步操作：

from langchain.prompts import ChatPromptTemplate

def analyze_request(state: AgentState) -> AgentState:
    """Analyzes the request and decides the next action"""
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an intelligent assistant. Analyze the user's request and determine the best way to respond."),
        ("user", "{input}")
    ])
    
    chain = prompt | llm
    
    result = chain.invoke({
        "input": state["user_input"]
    })
    
    state["response"] = result.content
    state["next_step"] = "respond"
    
    return state

3.3 - 响应节点

该节点格式化并返回最终响应：

def generate_response(state: AgentState) -> AgentState:
    """Generates the final response"""
    
    # Add response to history
    state["messages"].append({
        "role": "assistant",
        "content": state["response"]
    })
    
    state["next_step"] = "END"
    
    return state

4.配置状态图

4.1 - 创建图表

现在，让我们将所有节点连接到状态图中：

from langgraph.graph import StateGraph, END

# Create the graph
workflow = StateGraph(AgentState)

# Add nodes
workflow.add_node("process_input", process_input)
workflow.add_node("analyze", analyze_request)
workflow.add_node("respond", generate_response)

# Define entry point
workflow.set_entry_point("process_input")

# Add transitions (edges)
workflow.add_edge("process_input", "analyze")
workflow.add_edge("analyze", "respond")
workflow.add_edge("respond", END)

# Compile the graph
app = workflow.compile()

4.2 - 图表可视化

LangGraph 允许您将图结构可视化：

from IPython.display import Image, display

try:
    display(Image(app.get_graph().draw_mermaid_png()))
except Exception:
    print("Graph visualization requires additional dependencies")

5.运行代理

5.1 - 执行简单查询

def run_agent(user_input: str):
    """Runs the agent with user input"""
    
    # Initial state
    initial_state = {
        "messages": [],
        "user_input": user_input,
        "response": "",
        "next_step": ""
    }
    
    # Execute the graph
    result = app.invoke(initial_state)
    
    return result["response"]

# Test the agent
response = run_agent("What is the capital of France?")
print(f"Response: {response}")

预期输出：

Response: The capital of France is Paris.

5.2 - 使用流式执行

对于交互式应用程序，可以使用流：

async def run_agent_stream(user_input: str):
    """Runs the agent with streaming"""
    
    initial_state = {
        "messages": [],
        "user_input": user_input,
        "response": "",
        "next_step": ""
    }
    
    async for event in app.astream(initial_state):
        for node_name, node_state in event.items():
            print(f"\n--- {node_name} ---")
            if "response" in node_state and node_state["response"]:
                print(f"Partial response: {node_state['response']}")

高级功能

检查点和持久性

LangGraph 支持检查点来保存状态：

from langgraph.checkpoint.memory import MemorySaver

# Add memory to the graph
memory = MemorySaver()
app_with_memory = workflow.compile(checkpointer=memory)

# Execute with persistence
config = {"configurable": {"thread_id": "user-123"}}
result = app_with_memory.invoke(initial_state, config)

条件和动态路由

您可以为路由添加条件逻辑：

def router(state: AgentState) -> str:
    """Determines the next node based on state"""
    
    if "urgent" in state["user_input"].lower():
        return "priority_handler"
    else:
        return "normal_handler"

# Add conditional routing
workflow.add_conditional_edges(
    "analyze",
    router,
    {
        "priority_handler": "priority_node",
        "normal_handler": "normal_node"
    }
)

使用案例

LangGraph 适用于

  1. 复杂的聊天机器人：利用上下文管理多轮对话
  2. 自主代理：创建基于状态决策的代理
  3. 处理工作流：协调数据处理管道
  4. 多代理系统：协调多个专业代理

实际应用

欲了解更多详情和实际案例，请访问

结论

LangGraph 为构建有状态的人工智能应用程序提供了一种强大而灵活的方法。通过将状态图与 LLM 相结合，您可以创建复杂的系统来管理复杂的对话、根据上下文做出决策并执行动态工作流。

LangGraph 的模块化结构允许您从简单的聊天机器人扩展到复杂的多代理系统，同时保持代码的有序性和可维护性。

谢谢

Discussion (0)1
Log in or sign up to continue