<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ricardo Olivieri on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Olivieri on Medium]]></description>
        <link>https://medium.com/@ricardo.olivieri?source=rss-88c89d5ae806------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*MFAIpPDFYL1BwNWOv-_3IQ.jpeg</url>
            <title>Stories by Ricardo Olivieri on Medium</title>
            <link>https://medium.com/@ricardo.olivieri?source=rss-88c89d5ae806------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:23:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ricardo.olivieri/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Agent2Agent Matters for Multi-Agent Systems?]]></title>
            <link>https://medium.com/ibm-watson-aiops/why-agent2agent-matters-for-multi-agent-systems-45c070fdd1b9?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/45c070fdd1b9</guid>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Sat, 06 Dec 2025 04:08:46 GMT</pubDate>
            <atom:updated>2025-12-06T04:08:46.214Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-iyizWOv-hvDIpF0Z4LJCw.jpeg" /></figure><p>In a previous <a href="https://medium.com/@ricardo.olivieri/why-is-model-context-protocol-relevant-for-agentic-systems-b2d5b8b121b8">article</a>, we discussed the relevance of MCP in the implementation of effective and collaborative multi-agent systems. As highlighted in that article, MCP provides the standardization of the inputs and outputs between agents <em>and</em> the tools those agents need to reach a final goal. The lack of standardized communication mechanisms between agents and tools introduces significant challenges in building resilient agentic systems, ultimately hindering the adoption of such solutions. Notwithstanding its considerable relevance and value, MCP is not the only protocol for enabling multi-agent systems. In this article, we introduce the Agent2Agent Protocol (A2A) and discuss its relevance in agentic systems.</p><p>The Agent2Agent protocol is an open standard, initially introduced by Google, for enabling seamless collaboration and interoperability between AI agents, regardless of their underlying frameworks, programming languages, LLMs, or vendors. Like MCP, A2A provides an agreed-upon format and structured messaging layer for agents to communicate. However, unlike MCP which focuses mainly on the communication between agents <em>and</em> tools, A2A focuses on facilitating agents to communicate with each other as <em>peers</em> (rather than just as tools). The A2A protocol standardizes how agents communicate to collaborate, delegate, and manage complex tasks among themselves. The A2A communication flow typically involves the following:</p><ul><li>Skill discovery: Agent declares its services and technical specifications in a JSON manifest, which is known as an Agent Card. Agent Cards conform to a standardized JSON manifest which describes an agent’s capabilities. Note that the description contained within an Agent Card is in human-readable format. This card allows client agents to identify the best agent for a given task.</li><li>Task request: Grounded in the specification of the retrieved Agent Card, the client agent composes a task and sends it to the remote agent that was determined to be the best agent suited for executing that task.</li><li>Task execution: The remote agent executes the task and sends a response to the client agent. The A2A protocol supports complex, multi-modal content exchange such as text, audio, and video.</li></ul><p>A2A protocol facilitates very compelling use cases that up to recently were challenging to implement. For example, within the financial services sector, a fraud detection agent can use A2A to consult with multiple risk assessment agents from different financial organizations to corroborate transaction patterns in real-time. As another example, within the IT Customer Support domain, an orchestrator agent uses A2A to direct customer queries to specialized agents. For example, one agent retrieves the customer’s support ticket history, another consults relevant knowledge bases, and a third drafts a response using the previous findings, the current issue, and the ticket history.</p><p>Let’s now go a bit deeper into how the A2A protocol supports and makes possible the collaboration and management of complex tasks across multiple agents. To aid in this discussion, see the diagram below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6X2vuNDX0LPQW9njCfOjg.jpeg" /></figure><p>In this example scenario, a business application relies on a multi-agent back-end system to process user questions (prompts). The business application interacts directly with only one agent, which is responsible for receiving requests or prompts from users (or from other systems). This agent first obtains the Agent Cards (1), from an agent registry, for all known agents that are available in the environment. This agent is usually referred to as the client agent since it is the entry point for all incoming requests.</p><p>Users of the business applications send a prompt (2), which is forwarded to the client agent for processing. When the client agent receives a request, the reasoning and selection process begins. A LLM provides the agent with the intelligence to understand the prompt, to determine the tasks to be executed, and to match agents with each task. Therefore, the incoming prompt along with the information in the Agent Cards (that were obtained from the agent registry) are provided as inputs (enhanced prompt) to the LLM (3). We can think of the LLM as the “mind” of the client agent for <strong>1)</strong> task breakdown and for <strong>2)</strong> matching agents with each identified task. The LLM uses its natural language understanding capability to compare and align the human-readable descriptions from the Agent Cards with the tasks in the input prompt.</p><p>After the LLM determines which agents should collaborate to reach a final response, the LLM returns an intermediate response to the client agent. The client agent examines this intermediate response in order to invoke the corresponding agents for delegating the identified tasks (4). This response conforms to a pre-defined A2A structure, which references the agents to be invoked and the parameters for those agents. With this information, the client agent has the necessary pointers to know which agents to call and what values to provide as inputs. The agents that are invoked from the client agent are usually referred to as remote agents.</p><p>For this example scenario, all delegated tasks require complex reasoning. Therefore, remote agents use an LLM as its core reasoning engine to process the task provided by the client agent (5). Also, in this example scenario, remote agents need and have access to remote tools, which are invoked as part of the execution of the assigned tasks (6). That said, please note that this may not be the case with all remote agents in other scenarios. A remote agent responsible for executing a single, deterministic task does not use or need a LLM or MCP for the invocation of tools. For such cases, the remote agents use the A2A protocol for interoperability and simply use traditional code for executing the assigned tasks.</p><p>After the client agent gathers all responses and execution results from the remote agents, the client agent parses those data structures to extract the relevant data fields in order to update the final prompt for the LLM. The client agent provides as input to the LLM an updated, enhanced prompt (7), which in non-technical terms asks the LLM the following: “Here is the data collected from all remote agents and the ask from the user. Please synthesize and generate a final, natural language response for the user that is clear and concise”. The client agent acts as the “orchestrator” between all remote agents and then delegates the final communication task back to the LLM. Once the client agent receives the final response from the LLM, the client agent sends the response to the user via the business application (8).</p><p>Now that we have a clear understanding of the overall flow and interactions in a multi-agent system that leverages the A2A protocol, let’s describe the lifecycle of a task assigned to a remote agent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/1*88LJaj7Fg7qn9UByqa7f7w.jpeg" /></figure><ol><li>Each remote agent is responsible for managing the lifecycle of the task it receives from the client agent.</li><li>Remote agent creates an A2A Task Object that maintains the state of the task execution. Remote agent also assigns a unique task identifier to the Task Object.</li><li>Remote agent returns to the client agent the task’s unique identifier as part of the response.</li><li>The client agent uses this unique identifier to track the task execution running in the remote agent (a common mechanism for the client agent to track the task is polling). Remote agent manages the status of the task (e.g., submitted, working, completed, etc.) by updating the Task Object accordingly.</li><li>Remote agent returns response to the client agent once the task is completed (response is usually returned via asynchronous polling). The response contains the status and result.</li></ol><p><strong>Conclusion</strong></p><p>Standardization is essential for developing multi-agent AI systems, both in declaring services and technical specifications of agents and in defining the inputs and outputs exchanged between them. Without a common communication framework, creating interoperable and maintainable agentic solutions becomes complex and slows adoption. The A2A protocol addresses these challenges by introducing three key elements:</p><ul><li><strong>Agent Cards</strong>, which define an agent’s capabilities and technical details,</li><li><strong>Standardized request formats</strong> for client agents to interact with remote agents, and</li><li><strong>Standardized response formats</strong> for remote agents to return results.</li></ul><p>By enforcing these standards, A2A ensures that client agents can discover remote agents, interpret messages consistently, and extract granular details such as task status and execution results from payloads. This unified approach, along with MCP, guarantees interoperability across the multi-agent ecosystem and simplifies integration, scalability, and long-term maintainability.</p><p><strong>References</strong></p><ul><li><a href="https://www.ibm.com/think/topics/agent2agent-protocol">What is A2A protocol (Agent2Agent)?</a></li><li><a href="https://www.youtube.com/watch?v=Tud9HLTk8hg">A2A Protocol (Agent2Agent) Explained: How AI Agents Collaborate</a></li><li><a href="https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/">Announcing the Agent2Agent Protocol (A2A)</a></li><li><a href="https://cloud.google.com/blog/products/ai-machine-learning/agent2agent-protocol-is-getting-an-upgrade">Announcing a complete developer toolkit for scaling A2A agents on Google Cloud</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45c070fdd1b9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/why-agent2agent-matters-for-multi-agent-systems-45c070fdd1b9">Why Agent2Agent Matters for Multi-Agent Systems?</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why is Model Context Protocol relevant for agentic systems?]]></title>
            <link>https://medium.com/@ricardo.olivieri/why-is-model-context-protocol-relevant-for-agentic-systems-b2d5b8b121b8?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2d5b8b121b8</guid>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Sat, 13 Sep 2025 19:41:43 GMT</pubDate>
            <atom:updated>2025-09-13T19:41:43.244Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yh7nZff3qvJ-F7YixNdSpQ.jpeg" /></figure><h4><strong>Authors: </strong><a href="https://medium.com/@ricardo.olivieri"><strong>Ricardo Olivieri</strong></a><strong>, </strong><a href="https://medium.com/@sourav.mazumder00"><strong>Sourav Mazumder</strong></a></h4><h3>Agentic AI and agents</h3><p>Agentic AI is a type of artificial intelligence implementation that functions autonomously by making decisions and performing complex, multi-step tasks with very little or no human intervention. An AI agent is an individual, specialized component within agentic systems. It is a program that functions for the most part without human intervention and, hence, is able to make decisions and take actions to achieve a given goal. An AI agent figures out what steps to take to meet a goal, by reasoning over ambiguous and unstructured data (e.g., natural language).</p><p>For bootstrapping an AI agent, the key inputs are the high-level goal to realize and the list of tools that support achieving that goal (along with access to those tools). Once an AI Agent is up and running, it reacts to incoming user asks. The AI agent determines the intent of the ask, decides which tools to leverage (e.g., whether to search a knowledge base, call a weather API, etc.), and formulates the response. Of course, an AI agent does this by leveraging a LLM(s). Also, note that executing a tool involves interacting with external systems such as controlling physical devices, getting the current weather, or placing an order to buy shares of a stock. An AI agent executes these activities without the human prompting for each sub-step.</p><p>As we covered in a <a href="https://medium.com/ibm-watson-aiops/model-context-protocol-a-game-changer-for-automation-5c2b27ac4b40">previous article</a>, the Model Context Protocol (MCP) standardizes and makes LLM-tool interactions quite seamless: MCP defines how the list of available tools should be compiled and provided to AI agents/LLMs and how AI agents (through an MCP client) should invoke tools for LLMs to formulate a final response. Therefore, MCP is key for the adoption and implementation of AI agents as part of an overall agentic AI solution. Though it is possible to implement agentic AI solutions without leveraging MCP, the required effort is much higher, which discourages software engineers and developers from implementing this type of systems.</p><h3>MCP and multi-agent systems</h3><p>A multi-agent system is comprised of two or more specialized AI agents that work together to achieve a larger goal. In this type of system, most agents need to interact with external tools (e.g., APIs, databases, event queues, etc.) to perform their specialized tasks. And to do so, as we have outlined previously, the MCP protocol is key. In this section we explore what other benefits MCP provide in the implementation of an agentic AI solution.</p><h4>Context</h4><p>In addition to invoking external tools, agents should maintain a common understanding of the ongoing ask in order to collaborate effectively. This common understanding is known as the context, which is absolutely needed to maintain coherence across all agents. For example, say there are two agents, Agent A and Agent B, and that for Agent B to start its task, it needs to know the outcome of the task from Agent A. To obtain this information (i.e., context), Agent B could query shared memory as long as Agent A and Agent B do share memory space. For those familiar with software development, the complexity from implementing shared memory between different processes should quickly come to mind such as memory contention, the need for all agents to agree on a common schema, the need for all agents to be collocated on the same infrastructure (e.g., VM), etc. Fortunately, this is another area where MCP helps by defining a universal schema for context, which explicitly specifies a common structure for representing and storing “user intent,” “conversation history,” “tool outputs,” and “current task goals”. When an MCP client sends an outbound MCP request, the request isn’t just “do X.” Instead, the request looks like something along the following lines: “do X, given this user ID, this current conversation turn, this previous actions’ results, and this overall goal.” Thus, the recipient of the request always has the necessary background to perform its task coherently (i.e., with context).</p><h4>AI agents as MCP servers and clients</h4><p>Besides interacting with external tools, agents in a multi-agent system need to invoke other agents. Since MCP’s primary goal is to standardize how LLMs and agents invoke external tools, an agent can expose its capabilities as an MCP server, enabling other agents to route requests to it seamlessly. In multi-agent systems, it is not unusual to find an orchestrator agent that functions as the entry point into the agentic platform, and whose main job is routing requests to other agents. This orchestrator agent can leverage MCP to gather and be aware of the available capabilities across the different specialized agents and then make the necessary agent-to-agent invocations to reach the final goal.</p><h4>Interoperability</h4><p>An attribute that is commonly found in robust multi-agent systems is interoperability. MCP clients and MCP servers (again note that both roles can be fulfilled by agents) enable and foster communication regardless of the underlying technology or how the servers or clients were built. This, of course, increases interoperability and modularity across the different AI components that make up a multi-agent, agentic system. Without standardization, building robust multi-agent systems would be quite painful since it would involve a lot of custom parsing, custom data transformation, and error-prone communication between the AI components.</p><h4>Lineage and debugging</h4><p>For debugging multi-agent solutions, it is critical to understand how decisions were taken and to have audit trails. MCP strives to deliver clear information to support the realization of these two. MCP includes details, in the context, such as “who initiated the ask,” “what the goal was,” and “why a tool was chosen.”. This, in turn, makes tracing the lineage of asks across multiple agents very feasible, which facilitates debugging these complex agentic systems.</p><h4>Modularity</h4><p>Agents that adhere to the MCP specification can be developed and deployed independently (e.g., plugged into any MCP-compliant orchestration solution). The MCP specification promotes a modular multi-agent architecture, where agents can be swapped, updated, or added without requiring coordination with the other agents in the system.</p><p>These benefits position MCP as a powerful enabler of next-generation intelligent systems. At the same time, using MCP is not without its challenges. Developers and architects must confront the security implications head-on — balancing innovation with vigilance.</p><h3>Security risks</h3><p>One concern or risk when using MCP is that there is a higher possibility of malicious inputs that could trick a LLM into performing unintended actions. This type of cybersecurity exploit is known as prompt injection. A malicious prompt may cause a LLM to provide a result that goes against the user’s intentions or security policies. For example, a malicious prompt could instruct a coding agent to write insecure code or to ignore certain security best practices. Using filters that compare user inputs to known injections can be used to aid in preventing malicious prompts. Granting LLMs and associated tools/APIs the lowest privileges necessary can limit the damage the malicious inputs could do. Also, keeping humans in the loop is considered good practice to prevent unwanted outcomes: humans manually verify LLM outputs and authorize their activities before these are executed.</p><p>Another risk is connecting to a malicious MCP server. A rogue MCP server can extract data and perform harmful actions. For example, a malicious MCP server can expose a tool that appears to simply automate actions in your, say, Google Drive but under the covers it is collective sensitive data from your documents. Therefore, it is of the uttermost importance to verify and validate the identity and ownership of the MCP server you intend to connect to. Using only official repositories mitigates the risk of trusting a rogue MCP server.</p><h3>Logical architecture view</h3><p>The diagram below represents a logical architecture view of an agentic system that uses MCP. The components on the right represent the tools (internal and external) that LLM(s) in the solution can make use of to reach the main goal. This includes the tools facade (i.e., MCP servers) that provides a simplified and standardized view into the available tools for LLM(s). The components on the left make up the core of the agentic system. Agents coordinate the interactions between LLM(s) and tools by making use of MCP via MCP clients (which in turn communicate with MCP servers).</p><p>Also, as shown in the diagram, it is quite common to find retrieval-augmented generation (RAG) components as part of the implementation of agentic systems. If you are not familiar with RAG, it is a mechanism to enhance the prompt with a well-founded and trustworthy knowledge base by retrieving pertinent information. The prompt is enhanced (i.e., augmented) with the retrieved information before the prompt is sent to the LLM. RAG allows LLMs to provide more accurate and context-aware responses by tapping into knowledge bases that are proprietary or specialized beyond the training data used for the LLM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*AKU-cBYUgsXUIr6mUXPbyQ.png" /></figure><h3>Conclusion</h3><p>For building effective, collaborative, and scalable multi-agent AI systems, standardization of the inputs and outputs between agents and tools, along with the inclusion of contextual data for tracing, debugging, and keeping coherence across all communication are needed. Agents should not just ask other agents to execute a given task, but also provide essential and key information such as the user who initiated the ask, results from the execution of previous actions/agents, the larger goal, etc. Without standardizing how agents communicate with each other and tools, building resilient and interoperable agentic solutions is challenging, which hinders the realization of such systems. MCP supports these needs and makes it easier to build agents that can act as both MCP clients and servers. It also helps speed up the process of developing and maintaining agentic systems. Finally, it is worth mentioning that MCP is not the only protocol for enabling multi-agent systems. Emerging protocols like Agent2Agent Protocol (A2A) and Agent Communication Protocol (ACP) look quite promising for enabling autonomous collaborative systems when used together with MCP. In an upcoming article, we briefly discuss these two protocols (A2A and ACP) and their relevance in agentic systems.</p><h3>References</h3><ul><li><a href="https://www.anthropic.com/news/model-context-protocol">Introducing the Model Context Protocol</a></li><li><a href="http://ttps//www.ibm.com/think/topics/model-context-protocol">What is Model Context Protocol (MCP)?</a></li><li><a href="https://modelcontextprotocol.io/docs/sdk">MCP SDKs</a></li><li><a href="https://opendatascience.com/stop-building-ai-agents-heres-what-you-should-build-instead/">Stop Building AI Agents. Here’s What You Should Build Instead</a></li><li><a href="https://opendatascience.com/understanding-ai-agents-from-hype-to-real-world-application/">Understanding AI Agents: From Hype to Real-World Application</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2d5b8b121b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Model Context Protocol — A Game Changer For Automation?]]></title>
            <link>https://medium.com/ibm-watson-aiops/model-context-protocol-a-game-changer-for-automation-5c2b27ac4b40?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c2b27ac4b40</guid>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Tue, 05 Aug 2025 12:30:49 GMT</pubDate>
            <atom:updated>2025-08-15T14:43:33.679Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D395GKFsOjekPzA5ufjASA.jpeg" /></figure><h3>Model Context Protocol — A Game Changer For Automation?</h3><p><strong>Authors: </strong><a href="https://medium.com/@ricardo.olivieri"><strong>Ricardo Olivieri</strong></a><strong>, </strong><a href="https://medium.com/@sourav.mazumder00"><strong>Sourav Mazumder</strong></a></p><p><strong>Introduction</strong></p><p>Generative AI and large language models (LLMs) have generated significant interest in the last few years across various industries, including healthcare, finance, education, insurance, and beyond. LLMs are trained on vast amounts of unstructured and unlabeled text data using self-supervised learning to determine the relationships between words. This eliminates the need for the time-consuming (and sometimes infeasible) task of manually labeling or annotating the training data. Additionally, technical advancements in hardware (such as GPUs and in-memory processing) and the on-demand availability of computing resources on the cloud have made training and deploying LLMs more affordable than in the past. All these attributes have made exploring and adopting LLMs and Generative AI quite attractive for businesses. This comes as no surprise, given that high-skilled employees can now utilize LLMs (those trained with high-quality, curated, and trustworthy data relevant to their field of work) to have a significant increase in productivity. This, along with the growing need for automation and the hunt for cost savings, is driving the demand for intelligent systems that leverage LLMs.</p><p>As intriguing and exciting as LLMs and Gen AI are, using LLMs to summarize documents or to peruse through an extensive library of documents is just the tip of the iceberg. In addition to generating new content (e.g., summarization, generating marketing letters, language translation, Q&amp;As, etc.), more interesting and complex use cases can be implemented when LLMs are enabled to execute actions. LLMs capable to execute actions can extensively automate processes in various industry use cases such as asset performance management, financial services, IT incident management, infrastructure lifecycle management in hybrid environments, and many others.</p><p>For example, a LLM with the means to execute actions makes streamlining the steps in processing a loan application for a home quite feasible. A back-end process for data acquisition and validation on the prospective home buyer that uses a LLM can trigger a workflow that relies on tools such as APIs across various external and internal systems:</p><ul><li>Loan application is picked up from processing queue.</li><li>Parse bank statement and other provided documents to extract relevant information.</li><li>Based on the supplied information in the loan application package, obtain relevant information on the prospective buyer such as the latest bank statement, latest wage and tax statement (e.g., W-2 form), and latest retirement savings plan statement (e.g., 401k) by calling the appropriate APIs of the target systems.</li><li>Invoke APIs provided by the credit bureaus (e.g., Equifax, Experian) to obtain buyer’s credit score.</li><li>Send email to the prospective home buyer (i.e., applicant) to ask for any additional, required information.</li><li>Verify initial eligibility of the applicant based on pre-defined business rules.</li><li>Send email to the underwriter with the processed application so he/she can make final risk assessment.</li></ul><p>Note that LLMs are somewhat limited in their capabilities when leveraged on their own. For realizing the type of use cases we outlined above, tool integrations for LLMs are key. In the context of the prior mentioned loan application process scenario, the tools could include emailing systems (SMTP email servers), business rules engines, and programmatic APIs (for getting data from internal and external data sources such as Experian).</p><p>To standardize and make LLM-tool interactions more feasible and practical at <em>scale</em>, the Model Context Protocol (MCP) was introduced in 2024. MCP defines an open standard for providing a LLM with a list of available tools so the LLM determines which should tool(s) to use depending on the input text or instruction that guides the LLM’s output (i.e., prompt). MCP aims to provide a turnkey experience for developers looking to integrate LLMs and tools, and, thus, avoid writing specific code for integrating each tool. This turnkey experience that MCP provides could be a game changer for the adoption of AI and LLMs as part of a broader automation strategy. For example, an AI solution for the management of IT incidents could include several components that leverage a LLM and a set of tools to identify, diagnose, and remediate IT incidents with minimal human intervention. Each of the AI components in this solution would have clear goals and would leverage MCP for enabling interactions between the LLM and external tools:</p><ul><li>Identifies anomalies in IT operational data such as time series data that represents consumption and usage of computational resources (e.g., CPU, memory, etc.)</li><li>Uses identified anomalies plus additional incoming IT operational data to determine whether an incident should be raised, and if so, then sends notifications via messaging, email, or ticketing systems.</li><li>Finds possible solutions for resolving the incident by using the LLM to analyze it, deciding which external data sources (such Red Hat Insights APIs and other trusted knowledge repositories) to query to obtain additional relevant information, and querying internal historical incident records.</li><li>Executes the solution that is most likely to resolve the problem and/or gets approval from an IT Ops staff member to execute the recommended solution.</li></ul><p>In the next section, we discuss how MCP simplifies the integration between LLMs and tools, which should result in more organizations taking on LLMs and Gen AI to implement automations that, say, improve employee productivity and efficiency, reduce operational costs, and that provide meaningful user experiences that helps them achieve their goals with minimal intervention.</p><p><strong>MCP Architecture</strong></p><p>MCP follows a client-server architecture, where each client has a 1-to-1 relationship with an MCP server.</p><p>MCP clients are responsible for transforming user requests into a structured format compatible with the open protocol, while MCP servers convert user requests into server actions. MCP uses JSON-RPC as its core communication protocol. Therefore, communication between MCP clients and servers is structured as JSON-RPC requests and responses. JSON-RPC makes it easier for different applications (i.e., MCP clients and servers) to interact and exchange data.</p><p>Note that MCP clients are built directly into AI applications (i.e., MCP clients reside within the AI application’s codebase), while the MCP server is an independent component from the AI Application that listens for requests from MCP clients. It is worth mentioning that that an AI application which contains an MCP client is usually referred to as the host. An MCP client is responsible for:</p><ul><li>Discovering the list of capabilities (e.g., tools) that an MCP server supports</li><li>Managing the tool execution on behalf of the LLM</li><li>Receiving data from the MCP server (e.g., receiving the output after the MCP server executes one of the capabilities it supports).</li></ul><p>Note that LLMs are just text generators and are not capable of executing tools themselves. Hence, the tool invocation is handled by another piece of software, the MCP server. We can think of tools as arbitrary functions (on the server side) to perform actions on behalf of the MCP client. Given that LLMs cannot invoke tools, MCP clients orchestrate the execution of tools by invoking the MCP server, getting the responses back from those executions, and providing those responses to the LLM. The LLM then uses these responses to generate the final response. A typical interaction flow between all these components is as follows:</p><ol><li>As part of the AI application codebase, the MCP client is instantiated.</li><li>The MCP client connects to the specified MCP server.</li><li>MCP client asks for list of available tools from the MCP server. This list includes the name of the tool along with a description of what each tool does.</li><li>AI application is now ready for interacting with the user.</li><li>AI Application receives request from user (i.e., user prompt).</li><li>AI application sends user prompt to LLM.</li><li>LLM determines that a response from an external tool(s) should be used to provide a final response.</li><li>LLM returns an intermediate response to the AI Application. Intermediate response includes references to one or more tools to invoke and the parameters to use.</li><li>MCP client asks MCP server to execute tools using the specified parameters.</li><li>MCP server executes corresponding tools, aggregates responses from tools into one unified response, which is sent to the MCP client.</li><li>AI application receives tool responses through MCP client.</li><li>AI application sends the tool responses to the LLM.</li><li>LLM generates final response.</li><li>AI application provides final response to user.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*YMUJ9-7R0FLCIr0hU9bGOg.png" /></figure><p>The above interaction flow illustrates some of the main benefits of using MCP:</p><ul><li>Decoupling of the execution of the tools from the AI application, and by doing so,</li><li>Multiple AI applications can leverage the same MCP server, avoiding reinventing the wheel.</li><li>AI application developers focus on business requirements and leave the plumbing code for implementing actions to the MCP server providers.</li></ul><p>For example, say that a service provider implements and deploys an MCP server to expose their tool catalog. AI applications that need to integrate those tools with a LLM, such as IBM’s <a href="https://www.ibm.com/granite">Granite</a>, can then use an MCP client to enable the LLM for tool invocations.</p><p><strong>Conclusion</strong></p><p>LLMs that cannot execute actions are limited in providing business value. Enabling LLMs to call internal and external tools for carrying out actions gives the means to AI applications to provide purposeful and meaningful value to organizations. The standardization provided by MCP simplifies the development efforts of such applications. MCP enables LLMs to interact with the external world to access tools in a consistent and predictable way. MCP eliminates the need for developers to create specific integrations for every LLM and external tool. Instead, developers leverage the standardized MCP interface, saving time and effort and reducing the risk of bugs and other defects. MCP not only streamlines development work but also makes it easier to maintain and extend AI applications. We believe that the standardization that MCP provides is a transformative breakthrough that should facilitate the implementation of automation across different industries. It is worth mentioning that there are MCP SDKs for several programming languages such as Python, Java, Kotlin, C#, Swift, and JavaScript. In an upcoming article, we will discuss how MCP facilitates the development of agentic AI systems.</p><p><strong>References</strong></p><ul><li><a href="https://www.anthropic.com/news/model-context-protocol">Introducing the Model Context Protocol</a></li><li><a href="http://ttps//www.ibm.com/think/topics/model-context-protocol">What is Model Context Protocol (MCP)?</a></li><li><a href="https://modelcontextprotocol.io/docs/sdk">MCP SDKs</a></li><li><a href="https://opendatascience.com/stop-building-ai-agents-heres-what-you-should-build-instead/">Stop Building AI Agents. Here’s What You Should Build Instead</a></li><li><a href="https://opendatascience.com/understanding-ai-agents-from-hype-to-real-world-application/">Understanding AI Agents: From Hype to Real-World Application</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c2b27ac4b40" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/model-context-protocol-a-game-changer-for-automation-5c2b27ac4b40">Model Context Protocol — A Game Changer For Automation?</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[New Features in IBM Cloud Pak for AIOps v4.3]]></title>
            <link>https://medium.com/ibm-watson-aiops/new-features-in-ibm-cloud-pak-for-aiops-v4-3-9627eae4c2cd?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/9627eae4c2cd</guid>
            <category><![CDATA[ibm]]></category>
            <category><![CDATA[cloud-pak]]></category>
            <category><![CDATA[it-automation]]></category>
            <category><![CDATA[aiops]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Wed, 17 Jan 2024 18:27:23 GMT</pubDate>
            <atom:updated>2024-02-20T19:37:12.086Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*cGcYGMi6DhsieTNRidxygA.png" /></figure><p>Authors: <a href="https://medium.com/@ricardo.olivieri">Ricardo Olivieri</a>, <a href="https://medium.com/@pratik-patel">Pratik Patel</a></p><p>In this blog post, we briefly highlight <strong><em>some</em></strong> of the new officially supported features introduced in the latest major release of IBM Cloud Pak for AIOps (CP4AIOps), <strong>v4.3</strong>.</p><p><strong>Programmatic integration with IT service management tools (ITSM)</strong></p><p>As our readers may know, CP4AIOps supports out-of-the-box integration (in the CP4AIOps UI console) with ServiceNow for the implementation of these three use cases:</p><ul><li>Incident creation</li><li>Similar tickers</li><li>Change risk assessment</li></ul><p>After many customer engagements, we’ve learned that these features have proven to be very valuable given the added insights for new and/or recurrent problems in their IT environments. With CP4AIOps v4.3, customers that do not use ServiceNow and instead use another ITSM tool (e.g., BMC Remedy, Jira) can now implement the aforementioned use cases. To do so, developers leverage the new set of ticketing APIs in the <a href="https://github.com/IBM/cp4waiops-connectors">Connectors SDK</a> for CP4AIOps. This SDK has been available for a while now, though it only supported ingestion of events, metrics, and topology (aka inventory) data. The implementation of this SDK is now expanded to allow for the ingestion of ticketing data (e.g., incident records, change request records, etc.). New API methods in the Connectors SDK facilitate the consumption of ticketing data into CP4AIOps by abstracting developers from understanding the internal Kafka and Elasticsearch schemas that CP4AIOps imposes on ticketing data. The recommended starting point for developing a custom connector for integration with an ITSM system is found in the <a href="https://github.com/IBM/cp4aiops-connectors-ticket-template">Ticket Integration Template</a> repository, which is publicly available in GitHub. As a prelude, here’s a snippet of code that shows how to ingest a ticket record into CP4AIOps:</p><pre>ticket = objectMapper.readValue(json.toString(), Ticket.class);<br><br>ticketAction.emitIncident(ticket, ConnectorConstants.SELF_SOURCE.toString());<br><br>ticketAction.insertIncidentIntoElastic(ticket);</pre><p><strong>Custom dashboards</strong></p><p>CP4AIOps v4.3 introduces an UI extension toolkit for developing <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=connections-creating-dashboards-using-dashboard-extension-toolkit">custom dashboards</a>, which are then accessible in the CP4AIOps UI console (through the Cloud Pak’s navigation system). For example, a custom dashboard can be implemented for summarizing and visualizing alerts and incidents data in a different format than the one displayed in the Incident and Alert Viewer pages. To build these custom dashboards, programming and web development skills are required, specially knowledge in <a href="https://www.typescriptlang.org/">TypeScript</a> and <a href="https://react.dev/learn">React</a> (<a href="https://react.dev/learn/typescript">React.ts</a>). The UI extension toolkit allows developers to access the same data sources available to the CP4AIOps product. Note that you could bring in and visualize in your custom dashboards third party data (for instance, you could leverage AJAX to communicate asynchronously with an external data source). It is worth mentioning that any custom dashboards that are deployed to the CP4AIOps base product do inherit the built-in security from the base product for authentication and authorization. The UI extension <a href="https://github.com/ibm/aiops-ui-extension-template">toolkit</a> is open source and available in GitHub. Therefore, we look forward to contributions (such as additional examples, enhancements, fixes, etc. ) from the large community of CP4AIOps users. Finally, we’d like to encourage our readers to check out the <a href="https://ibm.github.io/aiops-ui-extension-template/">storybook</a> that our CP4AIOps engineering team put together for visual examples.</p><p><strong>Invoke Impact policies based on incident attributes</strong></p><p>As mentioned in a previous <a href="https://medium.com/ibm-watson-aiops/new-features-in-ibm-cloud-pak-for-aiops-v4-1-99f080f67cb2">blog post</a>, CP4AIOps provides an out-of-the-box integration for <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=integrations-tivoli-netcoolimpact-connections">Netcool/Impact</a>. Using this integration, you can have CP4AIOps invoke remotely hosted Impact policies to, for example, enrich alerts or notify downstream tools/systems when certain alerts are seen. What is new in CP4AIOps v4.3 is that you can trigger the <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=policies-invoke-impact-policy">invocation</a> of an Impact policy based also on the attributes (or properties) of an incident (prior to this release, you could only trigger an Impact policy based on the attributes of alerts). With this new enhancement, you can trigger the invocation of an Impact policy when, say, an incident’s priority escalates from 5 to 1 (1 equates to the highest priority level in CP4AIOps). This new enhancement makes the execution of external, coarse-grained actions possible since such can be tied to the incident lifecycle (i.e., creation and updates of incidents) as opposed to only the lifecycle of alerts.</p><p><strong>Infrastructure Management connector</strong></p><p>A new out-of-the-box <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=connections-infrastructure-management">connector</a> is now available for ingesting events that are sourced from the <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=infrastructure-management">Infrastructure Management</a> component in <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=infrastructure-automation">Infrastructure Automation</a> (note: the Infrastructure Automation instance must be deployed to a Red Hat OpenShift cluster). Infrastructure Management collects events from underlying infrastructure such as hosts and virtual machines. Ingesting such events into CP4AIOps can provide insights about circumstances and situations (e.g., a VM was powered off, a VM migration has begun, a physical host has been disconnected, etc.) in the infrastructure that supports your application and other workloads, which in turn can be very useful for incident and root cause analysis across your IT environments.</p><p><strong>Leverage fields in the </strong><strong>alert.details element when defining policies</strong></p><p>When specifying conditions that define which alerts an <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=policies-policy-editor">automation policy</a> should look for and match, you can now in v4.3 take advantage of the new granular support for the fields contained in the alert.details field. The alert.details element (see<a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=reference-alert-event-schemas"> Alert schema</a> for further details) is generally formatted as an object of names and values pairs (where both of these are scalar strings), for example:</p><pre>{&quot;additionalProp1&quot;:&quot;prop1Value&quot;, &quot;additionalProp2&quot;:&quot;prop2Value&quot;, &quot;additionalProp3&quot;:&quot;prop3Value&quot;}</pre><p>With this new capability, you can define a condition that looks for a given name and value pair value, such as &quot;datacenter&quot;:&quot;New York&quot; . As reference, see image below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*C_h7ij0T_r1uAWxRs0Ix0A.png" /></figure><p><strong>Log anomaly — golden signals</strong></p><p>The l<a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=algorithms-about-golden-signals-log-anomaly-detection">og anomaly — golden signals</a> algorithm was introduced in the previous version, v4.2, as a technical preview. In v4.3, log anomaly — golden signals pipeline is now generally available (GA) and production-ready. Though log anomaly detection utilizing natural language processing (NLP) and statistical baseline algorithms continues to remain available in v4.3, we encourage customers to use the new golden signals pipeline.</p><p>Taking feedback from our customers into action, this new log anomaly detection pipeline iteratively learns and adjusts the machine learning model for identifying anomalies as incoming logs are ingested. This significantly simplifies the process of keeping the machine learning model up-to-date and improves the signal-to-noise management of log anomaly detection. Also, the classification of log data into one of CP4AIOps’ seven golden signals (latency, error, availability, exception, traffic, saturation, and information) aims to reduce alert noise, minimize false positives, and generate genuine alerts when abnormal behavior is detected. Explainability is also significantly improved by providing access to computed log templates (aka log patterns), alert counts against those templates, and to raw logs on the CP4AIOps UI console.</p><p>IT operations teams can then in turn use identified anomalies in system and application logs to facilitate root cause analysis and the resolution of incidents.</p><p><strong>Custom Alert View</strong></p><p>The Alert Viewer in CP4AIOps brings together alert details, alert severity, and alert filtering on a single, intuitive page. In addition to this, CP4AIOps v4.3 provides the ability to create and manage custom, detailed <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=alerts-creating-views">alert views</a> to suit an IT organization’s business requirements. For example, a Network Operations Center (NOC) team can simplify their tasks by defining custom view(s) in CP4AIOps tailored to support their specific needs. Such view(s) would render incoming network alerts in a pre-decided and agreed upon format, thus, ensuring that all NOC operators share the same tailored custom view(s).</p><p>This new capability in v4.3 provides flexibility to rearrange the Alert View in ways that it was not possible in previous releases of CP4AIOps. For example, as part of the definition of a custom view, you can select or specify:</p><ul><li>The columns (i.e., alert attributes) to render and the order of these columns in the view</li><li>Sorting prioritization for columns</li><li>The data alignment in the cells</li><li>A custom name for column headers</li><li>The columns that should be clickable, thus, enabling navigation to other pages</li><li>The width for columns</li><li>The CP4AIOps users can can edit and use the view</li></ul><p><strong>Topology — Geographic information system data</strong></p><p>CP4AIOps v4.3 features an exciting new geographic information system (GIS) capability for modeling the geographical location of managed resources, physical (e.g., buildings, data centers, fan, servers) and logical (e.g., virtual machines, processes, containers) along with events (e.g., floods, fires, storms). This new GIS functionality offers effective operations management, allowing for location-aware management of applications, services, and infrastructure.</p><p>Along with the attributes associated with topology resources in previous releases (such as name, tags, entityTypes, etc.), v4.3 adds a new attribute, geolocation, which captures the location of the resource.</p><p>Here are some examples on how organizations can leverage this new GIS capability:</p><ol><li>Enhance customer service by letting users know of problems in a specific geographical region.</li><li>Determine whether bad weather (e.g., floods, storms), fires, or social unrest could impact infrastructure and services.</li><li>Optimize truck-rolls by identifying suitable locations for technicians to install or replace equipment.</li><li>Leverage location data while assessing an organization’s resilience capabilities for infrastructure and services.</li></ol><p><strong>Wrap-up</strong></p><p>Our Solution Engineering team at <a href="https://www.ibm.com/products/expertlabs">IBM Technology Expert Labs</a> supports customers in their adoption of CP4AIOps (and also of our other products under the IT Automation portfolio). We support customers in defining the architectural deployment for CP4AIOps and identifying the integration points with their existing IT monitoring and observability tools. CP4AIOps enables organizations to minimize disruptions and outages in their IT environments <em>and</em> resolve IT problems quickly when they occur. Site reliability engineers (SREs) and IT operations team members are empowered to save significant time in detecting and remediating incidents with the advanced AI and analytics capabilities in CP4AIOps. For information on additional <em>new</em> capabilities and features (including tech previews) in this latest release of CP4AIOps, please take a look at the <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=notes-whats-new">release notes</a>. Finally, for specific information about the included vulnerability fixes, see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.3.0?topic=support">Support</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9627eae4c2cd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/new-features-in-ibm-cloud-pak-for-aiops-v4-3-9627eae4c2cd">New Features in IBM Cloud Pak for AIOps v4.3</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Similarities and differences between Cloud Pak for AIOps and AIOps SaaS]]></title>
            <link>https://medium.com/ibm-watson-aiops/similarities-and-differences-between-cloud-pak-for-aiops-and-aiops-saas-ff1b9c1e116?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff1b9c1e116</guid>
            <category><![CDATA[cloud-pak]]></category>
            <category><![CDATA[aiops]]></category>
            <category><![CDATA[operations]]></category>
            <category><![CDATA[ibm]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Fri, 08 Sep 2023 14:53:42 GMT</pubDate>
            <atom:updated>2023-09-08T14:53:42.186Z</atom:updated>
            <content:encoded><![CDATA[<p>Authors: Ricardo Olivieri, Isabell Sippli, Paul Watkins</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/1*szHO_0MYmpqAVVjql4tmWQ.png" /></figure><p>IBM has released two major milestones in our AIOps Platform portfolio — Cloud Pak for AIOps v4.1 and AIOps Insights (a SaaS offering). Our AIOps Platform solutions both address the following challenges in Ops:</p><ul><li>Resolving incidents takes too much time, because resolution relevant information is spread across various siloed tools, like Application Performance Management solutions, Network Performance Monitoring Tools, Infrastructure monitoring Tools, Security Information &amp; Event Management Tools, etc.</li><li>Such information, e.g. events, environment changes, KPIs, logs is not correlated into a single record, and even if it is correlated, there is no indication what the probable cause could be.</li><li>Even if the probable cause of an incident is found, it is not clear how to fix it.</li><li>There is no single pane of glass to investigate status and health of a managed environment, across silos.</li></ul><p>While our two solutions CP4AIOps 4.1 and AIOps Insights address these challenges, there are similarities and differences, and this blog post will detail those. We aim to provide clarity on which one of these two solutions an organization should choose as part of their AIOps adoption journey.</p><p>Before we describe the differences with CP4AIOps 4.1 and AIOps Insights, we’d like to outline first the most relevant similarities that exist among the options. They are both Incident Management solutions and, as such, they both address the use cases of data aggregation and noise reduction along with triaging and remediation of incidents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oa1enu6HNQPRR8pCqdb7ew.png" /></figure><p>In particular, the two solutions focus on the following capabilities:</p><ul><li>Aggregate and normalize IT operational data from disparate tools</li><li>Visualize real-time IT environments (i.e., visualization of application and supporting infrastructure topology)</li><li>Use artificial intelligence to correlate data into incidents (through event correlation and compression)</li><li>Quickly identify probable cause of an incident</li><li>Augmented incident remediation by applying AI/ML</li></ul><p>Let’s now go over the main approaches across these two AIOps Platform solutions for Incident Management.</p><p><strong>Data residency (data localization)</strong></p><p>CP4AIOps is a software product that can be deployed to any Red Hat OpenShift environment that meets the required <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.2?topic=installing-planning">SW and HW requirements</a>. Therefore, you can deploy CP4AIOps to an OpenShift cluster that runs privately within an organization’s on-premises environment <strong><em>or</em></strong> to a remote OpenShift cluster on a cloud provider such as IBM Cloud, Azure, GCP, or AWS. For IT organizations that prefer their operational data be kept within the confines of their on-premises environment or within their cloud provider of choice, CP4AIOps allows them to do just that. Some organizations have stringent security requirements and, consequently, they cannot send their operational data to another cloud provider’s environment or have their data leave their own on-premises data centers.</p><p>AIOps Insights is a SaaS offering that runs on AWS and provides off-the-shelf integrations to cloud providers, Application Performance Monitoring tools, and containerization platforms. This implies that operational data from these data sources needs to leave those confinements for it to be ingested into AIOps Insights. An IT organization that is allowed to do so can then leverage AIOps Insights.</p><p><strong>Extensibility and richness</strong></p><p><strong>AIOps Insights</strong> <strong><em>only</em></strong> ingests data through the off-the-shelf integrations it provides. At the time of writing, AIOps Insights provides off-the-shelf integrations for the following data sources:</p><p><strong>Containerization platforms</strong></p><ul><li>Kubernetes</li><li>Red Hat OpenShift</li><li>Docker</li></ul><p><strong>Cloud providers</strong></p><ul><li>IBM Cloud (<a href="https://www.ibm.com/products/openshift">Red Hat OpenShift on IBM Cloud</a> and <a href="https://www.ibm.com/cloud/kubernetes-service">IBM Cloud Kubernetes Service</a>)</li><li>Azure (<a href="https://azure.microsoft.com/en-us/products/kubernetes-service">Azure Kubernetes Service</a>)</li><li>Amazon Web Services (AWS)<br>- Collects data from Kubernetes and Virtual Machines (Linux) deployed to Amazon Elastic Compute Cloud (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html">Amazon EC2</a>)</li><li>Google Cloud Platform (GCP)<br>- Collect data from virtual machines running (Linux) deployed to Google Cloud Compute Engine</li></ul><p><strong>Application Performance Monitoring (APM) tools</strong></p><ul><li>Instana (in addition to infrastructure topology, it also gathers application topology)</li><li>AppDynamics</li><li>Dynatrace</li><li>Datadog</li><li>Zabbix</li><li>IBM APM</li><li>Splunk</li><li>New Relic</li></ul><p><strong>Network Performance Monitoring tools</strong></p><ul><li>SevOne</li></ul><p>Wherever possible, AIOps Insights will ingest topology, metrics, and events together, and associate the individual data points with each other automatically, with no further configuration.</p><p>For details on the many out of the box (OOTB) integrations available in <strong>CP4AIOps</strong>, please see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.2?topic=defining-connections-integrations">Defining connections and integrations</a>. There you will find a long list of integrations for ingesting IT operational data from many data sources. Also, CP4AIOps supports ingesting data from all <a href="https://www.ibm.com/docs/en/netcoolomnibus/8?topic=probes-probe-integrations.">Netcool probes</a> and ingesting event data through <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.2?topic=connections-generic-webhook">webhooks</a>. If an OOTB dedicated connector does not exist for your event data source, you can define a webhook integration that consumes JSON event payloads.</p><p>Using OOTB connectors, CP4AIOps can:</p><ul><li>Ingest application and system logs to identify anomalies. When anomalies are identified, these are raised as internal alerts that are correlated with the alerts coming from external data sources.</li><li>Ingest change requests records (from ServiceNow) to perform change risk assessment in order to identify change requests that are likely to be risky and could end up causing outages or problems in the IT environment.</li><li>Ingest historical incident records (from ServiceNow) to correlate previous incidents and known solutions to new incidents. These added insights empower IT operations staff to resolve problems quicker, significantly reducing the time to diagnose and remediate.</li><li>Notify IT operations staff when a new incident is created by sending a notification to a ChatOps tool (Slack or MS-Teams). The incident notification on the ChatOps user interface contains meaningful and descriptive information about the problem as well as relevant links to the corresponding views on the CP4AIOps console (as a side note, AIOps Insights supports sending only individual alerts to Slack). These notifications points IT operations teams straight to the cause of an incident, accelerating the process of identifying and resolving problems.</li></ul><p>CP4AIOps also allows for the implementation of <a href="https://github.com/IBM/cp4waiops-connectors-java-template">custom connectors</a> in addition to its <strong><em>many</em></strong> OOTB connectors (e.g., Instana, Netcool, Dynatrace, etc.). The capability to implement custom integrations opens the door for ingesting data from the observability and monitoring tools of your choice into CP4AIOps.</p><p><strong>Setup and configuration</strong></p><p>As mentioned previously, CP4AIOps can be installed anywhere that Red Hat OpenShift runs, such as on a cloud provider’s infrastructure or on-premises. Hosting and monitoring an OpenShift cluster has its own set of requirements, which some IT organizations do not want to take upon themselves and/or don’t have the necessary skills to do so. For these organizations, a SaaS offering is more attractive since they can just focus on leveraging the AI and ML capabilities for IT operations without having to worry about, say, applying security patches, procuring more HW for storage, monitoring the health of the systems and infrastructure where the AIOps tool is deployed to, etc.</p><p>For defining integrations with AIOps Insights, users simply download code from the AIOps Insights console that you then deploy quickly to the target/data source environments. This approach simplifies the configuration effort since there are no forms to fill out with URLs, usernames, passwords, and custom configuration properties. Simplicity is pervasive in the way that integrations are created for AIOps Insights.</p><p>For defining integrations with CP4AIOps, users need to provide connectivity parameters (e.g., hostnames, URLs, IP addresses, authentication credentials, etc.). which makes the process a bit more involved. With that and as part of defining these integrations, CP4AIOps provides more granular control over the data to be ingested, hence, giving users more control and flexibility.</p><p><strong>Data types</strong></p><p>AIOps Insights consumes events, metrics, and topology data. By ingesting and augmenting this data with AI/ML, AIOps Insights can correlate alerts, reduce noise that distracts IT operations staff, and identify probable cause among other capabilities.</p><p>In addition to events, metrics, and topology data, CP4AIOps collects:</p><ul><li>Application and system logs (for log anomaly detection).</li><li>Historical change request records to determine the potential risk of implementing new change requests in an IT environment.</li><li>Historical incident records in order to associate these with new incidents that are similar.</li></ul><p>By tapping into these additional types of data and applying AI/ML algorithms to it, CP4AIOps can correlate these (and the added insights) with events, metrics, and topology.</p><p><strong>Conclusion</strong></p><p>We started this write-up by first describing the similarities that exist across CP4AIOps and AIOps Insights, given that both are Event and Incident Management solutions. We then proceeded to highlight <em>some</em> of the main approaches across both options. Such options can be used to decide what offering is a best fit for an IT organization. For instance, if an IT organization leverages any of the operational tools for which AIOps Insights provides OOTB integrations, then the effort for configuring such integrations and getting results is much less when using AIOps Insights. On the other hand, if an IT organization needs to ingest data from data sources that AIOps Insights does not support <strong><em>or</em></strong> if the IT organization needs more granular control over the operational data, and/or there is a need to keep all operational data within the confinements of an on-premises data center, then CP4AIOps is a better fit.</p><p><strong>Acknowledgements</strong></p><p>We’d like to thank Jacob Yackenovich and Jeremy Hughes for their invaluable review and feedback on this article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff1b9c1e116" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/similarities-and-differences-between-cloud-pak-for-aiops-and-aiops-saas-ff1b9c1e116">Similarities and differences between Cloud Pak for AIOps and AIOps SaaS</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[New Features in IBM Cloud Pak for AIOps v4.1]]></title>
            <link>https://medium.com/ibm-watson-aiops/new-features-in-ibm-cloud-pak-for-aiops-v4-1-99f080f67cb2?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/99f080f67cb2</guid>
            <category><![CDATA[netcool]]></category>
            <category><![CDATA[aiops]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[ibm]]></category>
            <category><![CDATA[watson-aiops]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Wed, 28 Jun 2023 20:35:37 GMT</pubDate>
            <atom:updated>2023-06-30T20:17:30.964Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*DxXw1JjQ88o-311pnXN9yQ.jpeg" /><figcaption>IBM Cloud Pak for AIOps</figcaption></figure><p>In this blog post, I briefly highlight <strong><em>some</em></strong> of the new features (officially supported <em>and</em> technology previews) introduced in the latest major release of IBM Cloud Pak for AIOps (CP4AIOps), <strong>v4.1</strong>.</p><p><strong>Grouping of topology resources</strong></p><p>We listened to our customers and CP4AIOps v4.1 provides the capability to refer to a collection of topology nodes (i.e., resource groups) as either an <em>Application</em> or a <em>Service</em>. Prior to this release, users could only use the term <em>Application</em> to do so. A topology resource group in CP4AIOps embodies software that is responsible for a main task in response to business and/or technical requirements. Though from a functionality perspective, there is no difference between <em>Applications</em> and <em>Services</em> in CP4AIOps, these two terms conceptually represent two different constructs. Telecoms usually use the term <em>Service</em> to refer to groups of interconnected and related components (e.g. switches, routers, firewalls, load balancers, etc.) that <em>exclusively</em> support the operation of networking and data communications, while the term <em>Application</em> is commonly used to refer to components that satisfy the tangible needs of end-users (different than, say, moving packets of data from one network to another).</p><p><strong>Stories are now Incidents</strong></p><p>The term <em>Incident</em> is now used to refer to the grouping of related events under one single cohesive notification. An Incident provides a holistic view of related alerts and outlines the alert(s) which has been identified as the most relevant and as the probable cause for the problem at hand. An Incident also includes added insights (such as metric and log anomalies) along with contextual information and automated recipes (i.e., Runbooks) to address the identified problem.</p><p><strong>REST APIs for incidents an alerts management</strong></p><p>New REST APIs in this release allow for the programmatic implementation of external programs that can query, update, and create alerts in CP4AIOps. Similar REST APIs are also available for management of incidents. For further details, see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=ira-swagger-document">IBM Cloud Pak for AIOps Issue Resolution API</a> (please note that some of these APIs are officially supported, while some are <em>technology previews</em> as of now).</p><p><strong>Multi-zone OpenShift cluster deployment for high availability</strong></p><p>From a redundancy perspective, you can “stretch” a single OpenShift cluster across multiple data centers within a single region. The use of a multi-zone deployment architecture for CP4AIOps is available now as a <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=considerations-multi-zone-hadr"><em>technology preview</em></a>. Day-to-day operations of a multi-zone OpenShift cluster are not that different from a cluster in single zone, since a multi-zone cluster is treated as a single cluster. A multi-zone cluster has its worker nodes spread across multiple availability zones within a single region (typically within a single city). When CP4AIOps is deployed across multiple data centers, the deployment process spreads replicas of CP4AIOps components across nodes in the multiple zones, thus providing additional availability capabilities (e.g., if one zone goes down, CP4AIOps should still remain operational).</p><p><strong>New integrations and automation capabilities</strong></p><ul><li><a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=connections-generic-webhook">Generic <strong>webhook</strong> connector</a> for ingestion of events. The CP4AIOps console provides a new user interface for defining webhook connections for ingesting event data, which opens the door for seamlessly consuming events from data sources that support webhook integrations.</li><li><a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=integrations-datadog-probe-integration">Probe</a> and <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=jobs-datadog-observer">observer</a> components for ingesting event and topology data, respectively, from <strong>Datadog</strong> (though note that both of these components are <em>technology previews</em> in this release).</li><li>A new <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=integrations-tivoli-netcoolimpact-connections">Netcool/Impact integration</a>, which allows CP4AIOps invoke remotely hosted Impact policies. Using this new integration you could, for example, leverage an existing Impact policy for emailing users or notifying downstream tools or systems when certain alerts are seen. You could also invoke Impact policies as a way to enrich alerts and send those back to CP4AIOps. This new integration along with the previously available <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=integrations-tivoli-netcoolomnibus-connections">Netcool connector</a> allow customers extend their existing Netcool installations with the advanced AI and analytics capabilities in CP4AIOps.</li><li>Launch-out capability to navigate from the CP4AIOps UI to external sites. This is known as a <em>client-side action</em> since it runs within the browser’s context. While defining a client-side action you specify a base a URL and optional parameters that are to be part of the final URL built at runtime. The values for these optional parameters can come from alert properties such as hostname, location, resource name, IP address, etc.</li></ul><p><strong>Seasonability</strong></p><p>An alert that is known to re-occur around the same time window (e.g., a certain day of the week, a certain time of the day, etc.) is known as a seasonal alert. Such alerts are clearly highlighted in the Alert Viewer in the CP4AIOps UI. Further details for a seasonal alert, such as the seasonal time windows and a list of the historical instances of the alert are available as well for more explainability (you can think of this as a calendar view of the alert’s historical instances).</p><p><strong>Tabular views for topology</strong></p><p>Having a table representation of topology data is very useful for dense interconnected topologies. In certain cases, the membership of the resource group is more relevant than the graphical representation of it. Also, in some situations a tabular view is just easier to consume and much more more performant than attempting to visualize very large topologies in a directed graph.</p><p><strong>New options and filtering capabilities for alerts</strong></p><ul><li>Though filtering capabilities for alerts is not a new feature, what is new is that you can create <em>personalized</em> filter conditions using alert properties. And these bespoke filters can then be saved, updated, and shared with other users of CP4AIOps. This new persistent capability for filters enhances collaboration between users and simplifies the effort for reviewing and understanding reported alerts.</li><li>You can now use the right-click context menu to apply a <strong><em>quick filter</em></strong> to display alerts that match a selected criteria. For example, you can quickly display only those alerts that occurred on the same resource.</li><li>You can now personalize the right-click menu items in the Alert Viewer table:<br>- Decide which menu items are hidden or visible.<br>- The arrangement (order) of menu items within the menu.<br>- Use dividers for grouping related menu items with dividers.</li><li>Users now have the option to apply a different color background for each severity level, thus controlling how alert severity is depicted in the Alert Viewer table.</li></ul><p>Our Solution Engineering team at <a href="https://www.ibm.com/products/expertlabs">IBM Technology Expert Labs</a> is excited to continue working with customers on the adoption of CP4AIOps. We help customers define the architectural deployment for CP4AIOps and identify the integrations with their existing monitoring and observability tools. By leveraging CP4AIOps, organizations can minimize disruptions and outages in their IT environments <em>and</em> resolve IT problems quickly when they do occur. Users can save significant time in detecting and remediating incidents with the advanced AI and analytics capabilities in CP4AIOps. For information on additional <em>new</em> capabilities and features in this latest release of CP4AIOps, please take a look at the <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=notes-whats-new">release notes</a>. For specific information about the included vulnerability fixes, see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/4.1.0?topic=support">Support</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99f080f67cb2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/new-features-in-ibm-cloud-pak-for-aiops-v4-1-99f080f67cb2">New Features in IBM Cloud Pak for AIOps v4.1</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[File Observers in CP4AIOps v4.7]]></title>
            <link>https://medium.com/ibm-watson-aiops/file-observers-in-waiops-3-4-eb8e720b3c90?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb8e720b3c90</guid>
            <category><![CDATA[it-operations]]></category>
            <category><![CDATA[watson-aiops]]></category>
            <category><![CDATA[ibm-watson]]></category>
            <category><![CDATA[topology]]></category>
            <category><![CDATA[ibm-cloud-pak]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Thu, 11 Aug 2022 21:39:41 GMT</pubDate>
            <atom:updated>2025-01-22T21:58:57.563Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/327/0*YD5MRfpZLtCjakxW.png" /></figure><h3>File Observers in CP4AIOps v4.8</h3><h4>Authors: <a href="https://medium.com/@ricardo.olivieri">Ricardo Olivieri</a>, <a href="https://medium.com/@mabubaker1947">Muhammad Abubaker</a>, <a href="https://medium.com/@tanush29">Tanush Sharanarthi</a></h4><p>In our previous <a href="https://medium.com/ibm-watson-aiops/rest-observers-in-watson-aiops-v3-4-4eb27a574d6d">article</a>, we described how to use REST observers to feed topology information from your environment into IBM CP4AIOps. In this article, we introduce File observers, which can also be used for ingesting topology information. We will walk you through the steps for defining a File observer instance using the CP4AIOps console and for defining the input topology file.</p><p><strong>Pre-requisites</strong></p><ul><li>To get the most out of this article, you should have CP4AIOps <strong>v4.8 </strong>successfully<strong> </strong>installed on your OpenShift cluster. You should also know your way around OpenShift.</li><li>You should expose the topology routes in your OpenShift cluster where CP4AIOps is installed. If you haven’t done this, please take a look at the Expose topology routes section in our previous <a href="https://medium.com/ibm-watson-aiops/rest-observers-in-watson-aiops-v3-4-4eb27a574d6d">article</a>.</li><li>You should obtain the username and password credentials for the Topology (aka Agile Service Manager) user. You obtain these values by inspecting the aiops-topology-asm-credentials secret found in the namespace where you installed CP4AIOps.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oTAxhsz3AJ2zJ0HjHOVABw.png" /></figure><p><strong>Access OpenAPI documentation for File observer</strong></p><p>Let’s first access the OpenAPI documentation for File observer colocated with your CP4AIOps <strong>v4.8 </strong>installation. From the OpenShift console, proceed to Networking &gt; Routes and search for the aiops-topology-file-observer route. Please take note of the value under the Location column for this route (e.g. <a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-151312.cp.fyre.ibm.com/1.0/file-observer">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TdsKJhEW4ijCsgQ-Yneoaw.png" /></figure><p>To obtain the URL for the File observer OpenAPI page, append swagger to the Location value of your aiops-topology-file-observer route (e.g. <a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-151312.cp.fyre.ibm.com/1.0/file-observer/swagger">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/swagger</a>). Navigating to this URL should take you to a page similar to the one captured in the screenshot below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1rUTSkR65T1lGtJlwF70Ug.png" /></figure><p>We recommend you explore the OpenAPI specification for File observer to get acquainted with the REST API methods that are available. Note that you can also access the OpenAPI specification for File observer on the official IBM CP4AIOps <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.8.0?topic=apis-topology-file-observer">documentation</a>.</p><p><strong>Anatomy of input file for File observer</strong></p><p>The main component types that make up an input file for File observer are Vertex V (nodes) and Edges ( E which is now deprecated in topology file instead the connections between nodes are added via the _references field). Lines in the file starting with a # character are ignored since they are treated as comments. For more information on the structure of a topology source file, please see <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=ui-configuring-file-observer-jobs">Configuring File Observer jobs</a> and <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=reference-properties">Properties</a>.</p><p><strong>Create and upload a simple topology file</strong></p><p>As an introductory example, we will define a simple topology comprised of one person and one department, where the person manages the department. The example file shown below captures such topology by utilizing two vertices connected by one edge.</p><pre># Vertex: components/nodes<br>V:{&quot;uniqueId&quot;:&quot;person1&quot;,&quot;name&quot;:&quot;person1&quot;,&quot;entityTypes&quot;:[&quot;person&quot;],&quot;matchTokens&quot;:[&quot;person1&quot;],&quot;tags&quot;:[&quot;my_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;department1&quot;,&quot;name&quot;:&quot;department1&quot;,&quot;entityTypes&quot;:[&quot;organization&quot;],&quot;matchTokens&quot;:[&quot;department1&quot;],&quot;tags&quot;:[&quot;my_app&quot;]}<br># Edges: Relationships between vertices:<br>V:{&quot;uniqueId&quot;:&quot;person1&quot;,&quot;_references&quot;:[{&quot;_edgeType&quot;:&quot;manages&quot;,&quot;_toUniqueId&quot;:&quot;department1&quot;}]}</pre><p>The _edgeType element in the edge component defines the relationship (e.g. manages) between resources in a topology. For a list of all pre-defined edge types supported out-of-the-box, please see <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=reference-edge-types">Edge types</a>.</p><p>Let’s upload to CP4AIOps our example topology file using the following HTTP POST invocation:</p><pre>curl -k -X &#39;POST&#39; -u &quot;&lt;username&gt;:&lt;password&gt;&quot; --header &#39;Accept: application/json&#39; --url &#39;https://aiops-topology-file-observer-&lt;namespace&gt;.&lt;domain&gt;/1.0/file-observer/files&#39; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/department.txt;type=text/plain&#39;</pre><p>where:</p><ul><li>namespace is the namespace where CP4AIOps was installed (e.g. cp4aiops).</li><li>domain is the domain name for your cluster.</li><li>topology-file is the full path on your local system of the topology file to upload. You should take note of the name of this file (e.g. department.txt) as we will need it while creating a File observer job instance.</li></ul><p>For example:</p><pre>curl -k -X &#39;POST&#39; --url &#39;<a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-151312.cp.fyre.ibm.com/1.0/file-observer/files&#39;">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files&#39;</a> -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/department.txt;type=text/plain&#39;</pre><p>If the upload was successful, you should not see a response from the execution of the command. Please note that if the file already exists, you <strong>cannot</strong> POST a new version of the file with the same name; attempting to do so throws the following error:</p><pre>{&quot;_error&quot;:{&quot;message&quot;:&quot;File already exists.&quot;,&quot;level&quot;:&quot;warning&quot;},&quot;messageBody&quot;:{&quot;message&quot;:&quot;File already exists.&quot;,&quot;level&quot;:&quot;warning&quot;}}</pre><p>To update the topology file after you’ve uploaded it, you can use the same REST invocation but change the HTTP verb from POST to PUT:</p><pre>curl -k -X &#39;PUT&#39; --url &#39;<a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-151312.cp.fyre.ibm.com/1.0/file-observer/files&#39;">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files&#39;</a> -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/department.txt;type=text/plain&#39;</pre><p>After updating a topology file, you should see a response from the server similar to this:</p><p>[&quot;Updated successfully&quot;]</p><p><strong>Create and configure a File observer job</strong></p><p>After uploading the input topology file, you can create an instance of File observer. On the CP4AIOps console, click Integrations, click on Add integration button on the upper right corner. Proceed to the Topology category, click the Observer jobs link, and click the Add a new job button. You should then see several observer options to choose from (see screenshots below).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PdATnbMO_WuKe-l2Zt2gGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qTZwUspdddf_7M9O5t_nYw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AnXZ7KZDDrM1deLbqpWP2g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2AViWtdnllOP-ngzEmnubw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_xtQLQbV1WIkF9cFerjHIg.png" /></figure><p>Choose the File observer tile and provide the configuration values shown below: FileObserverTest for Unique ID; for File Mode choose Use server file option ; for File Name, use the name of the file you uploaded previously (i.e. department.txt); and for Provider, use a name of your liking such as testApp.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ydsJQbMlTynMPNUglCGugw.png" /></figure><p>Note that to create the above File observer job, you should first upload the topology file (e.g. department.txt) to CP4AIOps (as we did in the previous section). Otherwise, there will be an error while creating the File observer job.</p><p>Click Save after entering the configuration values. You should then see a tile like the one shown below for your newly created File observer. Right after creating a File observer job, it will start executing and processing the uploaded topology file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*idr_lCP8oK4j0oNhVXyNNg.png" /></figure><p>You can see the outcome of its execution by choosing the View history menu option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJHCxp6bW_E_1D7dzVEfBw.png" /></figure><p>If a File observer job fails its execution, the Details column shows a potential reason. One of the most common reasons for failures is providing a wrong file name during the configuration of a File observer job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mceia6cRXOSpT7mAp3BNJw.png" /></figure><p>In CP4AIOps v4.8, you can also upload a topology file by drag-and-drop functionality while defining a <em>new</em> File observer job. Please note that the extension of the topology file must be a.txt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*18fGpb6o3VlCDTeF4N8ZLw.png" /></figure><p><strong>View the uploaded topology</strong></p><p>Using Resource management section of the CP4AIOps console, you can visualize the topology configuration specified in the input file. You can use the keyword my_app to search for the topology (note that my_app is the <strong>tag</strong> value we assigned to both elements, person1 and department1, in the topology file).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O3k8EC1WBPsYyMNzoMyhrw.png" /></figure><p>Clicking on either of the resources available would reveal the following topology diagram.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wa3Had10HLCL1tMq364gTw.png" /></figure><p>By default, File observers only run <strong>once</strong>, right after creation. To run them again, you have to manually kick off their execution. Having said that, note that you can schedule the execution of a File observer job to occur at regular intervals (e.g. every hour).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HTGpADwPSsUnae6Tja_0nQ.png" /></figure><p><strong>Create and upload a more complex topology file</strong></p><p>Let’s now go over a second example which is more closely aligned to applications and servers. In this example, we have a topology file named application.txt that contains one server host1, which is connected to four different applications: app1, app2, app3, and app4. Also, we define a relationship between app1 and app4, where app1depends on (invokes) app4.</p><pre># Vertex: components/nodes<br>V:{&quot;uniqueId&quot;:&quot;app1&quot;,&quot;name&quot;:&quot;app1&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app1&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app2&quot;,&quot;name&quot;:&quot;app2&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app2&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app3&quot;,&quot;name&quot;:&quot;app3&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app3&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app4&quot;,&quot;name&quot;:&quot;app4&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app4&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;host1&quot;,&quot;name&quot;:&quot;host1&quot;,&quot;entityTypes&quot;:[&quot;host&quot;],&quot;matchTokens&quot;:[&quot;host1&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;],&quot;connections&quot;:&quot;4&quot;}<br># Edges: Relationships between vertex:<br>V:{&quot;uniqueId&quot;:&quot;host1&quot;,&quot;_references&quot;:[{&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app1&quot;},{&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app2&quot;},{&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app3&quot;},{&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app4&quot;}]}<br>V:{&quot;uniqueId&quot;:&quot;app1&quot;,&quot;_references&quot;:[{&quot;_edgeType&quot;:&quot;dependsOn&quot;,&quot;_toUniqueId&quot;:&quot;app4&quot;}]}</pre><p>Using the command below, let’s upload this new topology file to CP4AIOps:</p><pre>curl -k  -X &#39;POST&#39; --url &#39;https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files&#39; -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/application.txt;type=text/plain&#39;</pre><p>Next, we will update the File Name value accordingly in the File observer definition. Otherwise, the new topology that we just uploaded won’t be processed. On the CP4AIOps console, Click on the three dots on the top right corner of the FileObserverTest job tile we created. Select View &amp; edit option and then update the File Name value in the definition.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-hp_pOmS3PT0VDRJy5rsuQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6m6qQhSrAJn9B77TGliK7A.png" /></figure><p>As before, click Run, and once the topology definition is processed, we can see the corresponding resources and relationships using Resource management(for searching, use the my_awesome_app keyword since that is the <strong>tag</strong> assigned to the elements of this new topology):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wRhH-CfkKI1IE1NVlidKg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wEGYCIs-8gJwYptcJlwmuw.png" /></figure><p>Let’s say that you intended to have uploaded the previous topology having app3 with a critical status. Replace the entry for app3 in the application.txt file with the following:</p><pre>V:{&quot;uniqueId&quot;:&quot;app3&quot;,&quot;name&quot;:&quot;app3&quot;,&quot;_status&quot;: [{&quot;status&quot;: &quot;CPU High&quot;,&quot;state&quot;: &quot;open&quot;,&quot;severity&quot;:&quot;critical&quot;}],&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app3&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}</pre><p>Use then the following HTTP PUT curl command to upload the topology file:</p><pre>curl -k -X &#39;PUT&#39; --url &#39;<a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files</a>&#39; -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/application.txt;type=text/plain&#39;</pre><p>To process the uploaded file, you should kick off the FileObserverTest job by clicking on the Run button (otherwise the changes won’t be shown on the topology view).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OsKJceHvMpa--kKVVU5D2w.png" /></figure><p>Once the FileObserverTest job finishes running, using Resource management, search again using the my_awesome_app keyword.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iHW-U00b3-fy1r5Rsbr8AA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G7XemTo8bAtxLuxnO1Kh4Q.png" /></figure><p>To remove the critical status from app3, replace the entry for app3 in the application.txt file with the following:</p><pre>V:{&quot;uniqueId&quot;:&quot;app3&quot;,&quot;name&quot;:&quot;app3&quot;,&quot;_status&quot;: [{&quot;status&quot;: &quot;CPU High&quot;,&quot;state&quot;: &quot;clear&quot;,&quot;severity&quot;:&quot;clear&quot;}],&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app3&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}</pre><p>Use then the following HTTP PUT curl command to upload the topology file and make sure that a response[“Updated successfully”] is returned back:</p><pre>curl -k -X &#39;PUT&#39; --url &#39;<a href="https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files">https://aiops-topology-file-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/file-observer/files</a>&#39; -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -H &#39;accept: application/json&#39;  -H &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; -H &#39;Content-Type: multipart/form-data&#39;  -F &#39;job_file=@/&lt;path&gt;/application.txt;type=text/plain&#39;</pre><p>Run the FileObserverTest again for changes to take affect on node app3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NwjkWNL0gTGSzMf8Nygrig.png" /></figure><p>Reload the topology and you should now see that app3 is <em>no</em> longer in a critical state.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rqh9YscAcFmIsyLsM0gWRQ.png" /></figure><p><strong>Conclusion</strong></p><p>In this article, we discussed how to leverage File observers to feed topology information into CP4AIOps. We went over several examples for defining resources and relationships between those resources. File observers are an excellent choice for uploading a large topology definition into CP4AIOps. File observers are great for ingesting topology information when there is no out-of-the-box topology observer. Finally, as shown in the article, after processing a topology file with a File observer, you can also augment (e.g. update the <em>state</em> of an element in) the topology.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb8e720b3c90" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/file-observers-in-waiops-3-4-eb8e720b3c90">File Observers in CP4AIOps v4.7</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[REST Observers in CP4AIOps v4.7]]></title>
            <link>https://medium.com/ibm-watson-aiops/rest-observers-in-watson-aiops-v3-4-4eb27a574d6d?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/4eb27a574d6d</guid>
            <category><![CDATA[ibm-cloud-pak]]></category>
            <category><![CDATA[ibm]]></category>
            <category><![CDATA[watson-aiops]]></category>
            <category><![CDATA[ibm-watson]]></category>
            <category><![CDATA[aiops]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Fri, 29 Jul 2022 19:25:45 GMT</pubDate>
            <atom:updated>2025-01-22T21:58:45.225Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*uwUrn98AS2pOcuXpYkuZmw.jpeg" /></figure><h3>REST Observers in CP4AIOps v4.8</h3><h4>Authors: <a href="https://medium.com/@ricardo.olivieri">Ricardo Olivieri</a>, <a href="https://medium.com/@mabubaker1947">Muhammad Abubaker</a>, <a href="https://medium.com/@tanush29">Tanush Sharanarthi</a></h4><p>IBM Cloud Pak for AIOps (CP4AIOps) <strong>v4.8 </strong>provides out of the box observers for seamlessly obtaining topology information from multiple environments such as Kubernetes clusters, OpenShift clusters, Rancher clusters, and VMWare vCenter among many other environments. However, if you have an environment for which there is no out of the box topology observer, you can ingest its topology information into CP4AIOps by leveraging a REST observer or File observer. REST and File observers are also very useful for the implementation of proof of concepts (PoCs), demo environments, and to augment the topology information gathered by an out-of-the-box observer. In this article, we go over the steps to get you started on leveraging a REST observer to feed topology information into CP4AIOps (in a follow-up article, we will cover the File observer).</p><p><strong>Pre-requisites</strong></p><p>To get the most out of this article, you should have CP4AIOps <strong>v4.8 </strong>successfully<strong> </strong>installed on your OpenShift cluster (v4.16+).</p><p><strong>Expose topology routes</strong></p><p>Before you can use the REST (or File) observer, you need to expose the Topology routes on your OpenShift cluster, if not already exposed. Go to your OpenShift console, navigate to Operators&gt; Installed Operatorsand search for the term IBM Netcool Agile Service Manager.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f2bK8AmtDc1oO2crS8EymA.png" /></figure><p>Click on the operator name, proceed to the Agile Service Managertab, click on aiops-topology, and select the YAML tab.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*id87cwQt8E4abZEIAx3V8A.png" /></figure><p>Using the YAML editor, add the following yaml element as a child item (if not already present) to the helmValuesASM section:</p><pre>global.enableAllRoutes: true</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TzT9e-uk5AziE-D7Cj-nWw.png" /></figure><p>Save and reload the YAML definition to verify the changes were saved. Proceed to Networking &gt; Routes and search for the aiops-topology-rest-observer route, which should now be available. Take note of the value under the Location for the aiops-topology-rest-observer route (e.g. <a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer</a>). You have successfully exposed the Topology routes!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CO4cb-1H5aK7LmtRWDVoFw.png" /></figure><p><strong>Access OpenAPI documentation for the REST observer</strong></p><p>Now that the Topology routes are available on your cluster, let’s access the <a href="https://swagger.io/specification/">OpenAPI</a> documentation for the REST observer colocated with your CP4AIOps v4.8 installation. To do so, append swagger to the Location value of your aiops-topology-rest-observer route, for instance:</p><pre><a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/swagger">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer</a><a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/swagger">/swagger</a></pre><p>where cp4aiops is the namespace where CP4AIOps was installed on your cluster and apps.o2-181262.cp.fyre.ibm.com is the domain for your cluster. Note that you can also access the OpenAPI specification for the REST observer on the official IBM CP4AIOps <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.8.0?topic=apis-topology-rest-observer">documentation</a>.</p><p><strong>Create REST observer</strong></p><p>Let’s now create an instance of the REST observer. On the CP4AIOps console, click Integrations, click on Add integration button on the upper right corner. Proceed to the Topologycategory, click the Observer jobslink, and click the Add a new jobbutton. You should then see several observer options to choose from (see screenshots below).</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*PdATnbMO_WuKe-l2Zt2gGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*qTZwUspdddf_7M9O5t_nYw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*AnXZ7KZDDrM1deLbqpWP2g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2AViWtdnllOP-ngzEmnubw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_xtQLQbV1WIkF9cFerjHIg.png" /></figure><p>Configure the REST observer and provide the configuration values shown below: chooselisten for job type, RESTListenerTest for Unique ID, and for Provider field, a name of your liking such as testApp.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BIjpOAqReQp23qitlp9VsQ.png" /></figure><p>Click Save after entering the configuration values. You should then see a tile like the one below for your newly created REST observer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cdoXY-V0dkYr_-GPHE0XcA.png" /></figure><p>Your new REST observer job is now ready to receive topology information. Please take note of the name you assigned to the REST observer (e.g. RESTListenerTest) since you will need it to execute the commands shown in the next section of this article.</p><p>For more information, please see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-aiops/4.8.0?topic=jobs-rest-observer">Configuring REST Observer jobs</a>.</p><p><strong>Define and update topologies using REST observer</strong></p><p>As the names suggests, the REST observer provides users with the ability to ingest data via HTTP REST endpoints. As an introductory example, let’s say we’d like to create a simple topology that is comprised of one person resource. To do so, you’d use an HTTP POST invocation similar to the following:</p><pre>curl -k -u &lt;username&gt;:&lt;password&gt; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: &lt;observer-name&gt;&#39; -d &#39;{<br>  &quot;name&quot;: &quot;Thomas Watson&quot;,<br>  &quot;uniqueId&quot;: &quot;Thomas Watson&quot;,<br>  &quot;entityTypes&quot;: [<br>    &quot;person&quot;<br>  ]<br>}&#39; &#39;https://aiops-topology-rest-observer-&lt;namespace&gt;.&lt;domain&gt;/1.0/rest-observer/rest/resources&#39;</pre><p>where:</p><ul><li>username and password are the credentials for the Topology (aka Agile Service Manager) user. You obtain these values by inspecting the aiops-topology-asm-credentials secret; this secret contains both values, username and password (see screenshot below). The username (at the time of writing) follows the following convention: aiops-topology-&lt;namespace&gt;-user (e.g. aiops-topology-cp4aiops-user).</li><li>observer-name is the name of your REST observer (e.g. RESTListenerTest).</li><li>namespace is the namespace where the CP4AIOps was installed (e.g. cp4aiops).</li><li>domain is the domain name for your cluster.</li><li>X-TenantID is cfd95b7e-3bc7-4006-a4a8-a73a79c71255. This is a fixed value since, at the time of writing, multi-tenancy is <em>not</em> supported.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NL-L63DnqLQa6xEY76oHgQ.png" /></figure><p>For example:</p><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;name&quot;: &quot;Thomas Watson&quot;,<br>  &quot;uniqueId&quot;: &quot;Thomas Watson&quot;,<br>  &quot;entityTypes&quot;: [<br>    &quot;person&quot;<br>  ]<br>}&#39; &#39;https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources&#39;</pre><p>After executing the above command, from the CP4AIOps console, you can navigate to the Resource managementpage and search for Thomas Watson under Resources tab, as shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*PdATnbMO_WuKe-l2Zt2gGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QQaj2otqhwf_sdGIpl3Ggg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fUZ3Mc7iTQnm_eBMwquiHQ.png" /></figure><p>You may now be wondering what entity types are available out-of-the-box in CP4AIOps besides person, which is the entity type value we used in the example above. For a list of all pre-defined entity types supported out-of-the-box (such as application, container computer, host, etc.), please see the <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=reference-entity-types">Entity Types</a> document for Agile Service Manager (which is part of CP4AIOps).</p><p>Let’s now go over another example, which is more closely aligned to applications and servers. The following three REST invocations show how to create two resources, a host and an application, and also how to define a relationship between these two resources (remember you’d need to adjust the <strong>password</strong>, <strong>host</strong>, and <strong>observer name i.e </strong>Job ID<strong> </strong>values accordingly):</p><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;name&quot;: &quot;myhost1.ibm.com&quot;,<br>  &quot;uniqueId&quot;: &quot;myhost1.ibm.com&quot;,<br>  &quot;entityTypes&quot;: [<br>    &quot;host&quot;<br>  ]<br>}&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262</a><a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">.cp.fyre.ibm.com/1.0/rest-observer/rest/resources</a>&#39;</pre><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;name&quot;: &quot;app1&quot;,<br>  &quot;uniqueId&quot;: &quot;app1&quot;,<br>  &quot;entityTypes&quot;: [<br>    &quot;application&quot;<br>  ]<br>}&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262</a><a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">.cp.fyre.ibm.com/1.0/rest-observer/rest/resources</a>&#39;</pre><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;_edgeType&quot;: &quot;connectedTo&quot;,<br>  &quot;_fromUniqueId&quot;: &quot;app1&quot;,<br>  &quot;_toUniqueId&quot;: &quot;myhost1.ibm.com&quot;<br>}&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/references">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/references</a>&#39;</pre><p>Once the resources and relationship are defined, you can use the Resource management page to search and see the corresponding topology:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OO13G_WJSNdI3VcZc0QNHg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9bbHdcGhrym35ZRnZOYK2A.png" /></figure><p>You should note that the _edgeType element defines the relationship (e.g. connectedTo) between resources in a topology. For a list of all pre-defined edge types supported out-of-the-box, please see <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=reference-edge-types">Edge types</a>.</p><p>Let’s now add one more application, app2, and a second host, myhost2.ibm.com, and also define a relationship between app1 and app2, where app1depends (invokes) on app2.</p><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>    &quot;name&quot;: &quot;myhost2.ibm.com&quot;,<br>    &quot;uniqueId&quot;: &quot;myhost2.ibm.com&quot;,<br>    &quot;entityTypes&quot;: [<br>      &quot;host&quot;<br>    ]<br>  }&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources</a>&#39;</pre><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>    &quot;name&quot;: &quot;app2&quot;,<br>    &quot;uniqueId&quot;: &quot;app2&quot;,<br>    &quot;entityTypes&quot;: [<br>      &quot;application&quot;<br>    ]<br>  }&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources</a>&#39;</pre><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>    &quot;_edgeType&quot;: &quot;connectedTo&quot;,<br>    &quot;_fromUniqueId&quot;: &quot;app2&quot;,<br>    &quot;_toUniqueId&quot;: &quot;myhost2.ibm.com&quot;<br>  }&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/references</a>&#39;</pre><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>    &quot;_edgeType&quot;: &quot;dependsOn&quot;,<br>    &quot;_fromUniqueId&quot;: &quot;app2&quot;,<br>    &quot;_toUniqueId&quot;: &quot;app1&quot;<br>  }&#39; &#39;<a href="https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/resources">https://aiops-topology-rest-observer-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/rest-observer/rest/references</a>&#39;</pre><p>As before, once the resources and relationships are defined, let’s use the Resource management to see the corresponding topology:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HEiMXSDQkvJ-cWR9qq69Hg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AmUfbOEVQMtSS-zBnx9KKA.png" /></figure><p>Let’s go one step further into this tutorial and assign a critical status to the nodeapp1. To do so, you first need to obtain the resource ID for nodeapp1. From the Resource management, click onMore details from the link against app1, and copy the _id value.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jiCF7JnMYLFWzaCxKD0vdg.png" /></figure><p>We then use this resource ID (e.g. cB9nuV1RQLe2YTrGzpSt6g) for app1 in the URL path of the HTTP POST invocation as shown below:</p><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;status&quot;: &quot;CPU High&quot;,<br>  &quot;state&quot;: &quot;open&quot;,<br>  &quot;severity&quot;: &quot;critical&quot;,<br>  &quot;description&quot;: &quot;CPU High&quot;,<br>  &quot;resourceIds&quot;: [<br>  &quot;cB9nuV1RQLe2YTrGzpSt6g&quot;<br>  ]<br>}&#39; &#39;https://aiops-topology-status-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/status/status/&#39;</pre><p>After running the curl command, reload the topology and you should see that app1 now has a critical status (i.e. it is highlighted in red).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1jSby5OQVBXaOygD-q7yJA.png" /></figure><p>To remove the critical status from app1, you can use the following HTTP POST curl command:</p><pre>curl -k -u &quot;aiops-topology-cp4aiops-user:&lt;password&gt;&quot; -X POST --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br> &quot;status&quot;: &quot;CPU High&quot;,<br> &quot;state&quot;: &quot;clear&quot;,<br> &quot;severity&quot;: &quot;clear&quot;,<br> &quot;description&quot;: &quot;CPU High&quot;,<br> &quot;resourceIds&quot;: [<br>   &quot;cB9nuV1RQLe2YTrGzpSt6g&quot;<br> ]<br>}&#39; &#39;<a href="https://aiops-topology-status-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/status/status/">https://aiops-topology-status-cp4aiops.apps.o2-181262.cp.fyre.ibm.com/1.0/status/status/</a>&#39;</pre><p>Reload the topology and you should now see that app1 is no longer in a critical state.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UfT96ZAS0hIH-A7s73JJ7g.png" /></figure><p>Please note that for <strong>clearing</strong> the critical status of a resource, the value of the status field in the JSON payload must be the same value (e.g. &quot;CPU High&quot;) used when the critical status was set (note the status value is <em>case sensitive</em>). Please see <a href="https://www.ibm.com/docs/en/nasm/1.1.22?topic=reference-status-state">Status (and state)</a> for a list of the status values (e.g. clear, minor, major, etc.) supported out-of-the-box.</p><p><strong>Conclusion</strong></p><p>In this article, we discussed how to leverage a REST observer to feed topology information into CP4AIOps. We went over several HTTP REST invocations for defining resources, relationships between resources, updating status of resources, and clearing the status of resources. REST observers are an excellent mechanism for ingesting topology information when there is no out-of-the-box topology observer and also for augmenting the topology information gathered by an out-of-the-box observer among other tasks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4eb27a574d6d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/rest-observers-in-watson-aiops-v3-4-4eb27a574d6d">REST Observers in CP4AIOps v4.7</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[New capabilities in IBM Cloud Pak for AIOps v3.4]]></title>
            <link>https://medium.com/ibm-watson-aiops/new-capabilities-in-ibm-cloud-pak-for-watson-aiops-v3-4-84d0e960be4c?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/84d0e960be4c</guid>
            <category><![CDATA[ibm-cloud-pak]]></category>
            <category><![CDATA[ibm-watson]]></category>
            <category><![CDATA[aiops]]></category>
            <category><![CDATA[it-operations]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Thu, 28 Jul 2022 18:31:08 GMT</pubDate>
            <atom:updated>2024-08-29T15:23:11.261Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*qHFCV3Msg8MdJRhBFV3phQ.png" /></figure><h3>New Features in IBM Cloud Pak for AIOps v3.4</h3><p>In this blog post, I briefly highlight some of the new <em>supported</em> features introduced in the latest major release of IBM Cloud Pak for Watson AIOps, v3.4.</p><p><strong>New connectors</strong></p><p>There are now out-of-the-box connectors for ingesting metrics data from <a href="https://www.appdynamics.com/">AppDynamics</a> and <a href="https://www.dynatrace.com/">Dynatrace</a>. Both of these connectors collect different types of metrics, including live and historical data. With these two new connectors, Cloud Pak for Watson AIOps can ingest metric data from these external data sources and then detect and report any anomalies in those metrics. Detected metric anomalies are reported as alerts, which can then be correlated with other events and alerts, using temporal, topological, and scope-based relationships. Note that, at the time of writing, topology and events data are <em>not</em> read via these two new connectors. For more information on these new connectors, please see:</p><ul><li><a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/3.4.1?topic=connections-appdynamics">Creating Appdynamics connections</a></li><li><a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/3.4.1?topic=connections-dynatrace">Creating Dynatrace connections</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*vsDr4r9IbR0RZgRiWhmpJg.png" /></figure><p><strong>New connector SDK</strong></p><p>A new connector SDK is now available that allows implementing custom integrations between external data sources and IBM Cloud Pak for Watson AIOps. This new SDK can be used to ingest <em>events, alerts, metrics, and topology</em> data. Once a custom connector is implemented, it is packaged as a container image that runs a <em>gRPC</em> client to communicate with IBM Cloud Pak for Watson AIOps. You can deploy the custom connector on the same Red Hat OpenShift cluster where Watson AIOps is deployed or on a remote environment closer to your external data source. For more information, we invite you to explore the official GitHub repository, <a href="https://github.com/IBM/cp4waiops-connectors">cp4waiops-connectors</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/1*5B-jpVq5N4UljnJZVjzXzA.png" /></figure><p><strong>Backup and restore</strong></p><p>There is now support for backing up and restoring IBM Cloud Pak for Watson AIOps. This process <em>includes</em> backing up the following relevant data assets:</p><ul><li>Log anomaly detection and metric anomaly detection templates and models.</li><li>Trained models for similar incident analysis.</li><li>Risk models, risk assessments, incidents, and ticket data assets for change risk assessment.</li><li>Active events and alerts, as well as historic alert information.</li><li>Runbook automations.</li><li>Topology data.</li><li>Policies.</li></ul><p>For more details on the requirements for implementing a successful backup and restore procedure for Watson AIOps, please see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/3.4.1?topic=administering-backup-restore-ai-manager">AI Manager backup and restore</a>.</p><p><strong>Feedback on change risk assessments</strong></p><p>Using the ChatOps user interface, users can now provide feedback on the <em>risk score</em> Watson AIOps assigns after assessing a change request ticket. Also, users can provide feedback on the relevancy of the change requests that Watson AIOps determined to be related to the assessed ticket. The feedback option is displayed as a <em>thumbs up</em> and <em>thumbs down</em> button under the change risk assessment as shown in the screenshot below. Providing feedback helps improve the quality of the change risk model, which should then result in even better risk scores. For more details, please see <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/3.4.1?topic=insights-change-risk-in-chatops">Change risk in ChatOps</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*yjgWhK3Jf5UpHJavjMTOpw.png" /></figure><p><strong>Parse output of an action</strong></p><p>You can now filter the output of <a href="https://www.ibm.com/docs/en/SSJGDOB_3.4.1/automations/runbooks_actions_script.html">SSH actions</a> or <a href="https://www.ibm.com/docs/en/SSJGDOB_3.4.1/automations/runbooks_actions_http.html">HTTP actions</a> to return only the data that you are interested in. If you would like to use the output of one action as input for another action (i.e. a chain multiple actions), then you will find this new capability extremely useful. To take advantage of this new capability, you define a pattern that dictates which part of the action output gets returned. There are <em>three</em> supported <em>pattern-matching</em> engines that you can choose from:</p><ul><li><em>XPath</em>: For parsing XML data.</li><li><em>JSONPath</em>: For parsing JSON data.</li><li><em>Regular expression</em>: For parsing other types of data such as unstructured data.</li></ul><p><strong>Additional capabilities</strong></p><p>For information on additional capabilities and features in this latest release of IBM Cloud Pak for Watson AIOps (such as vulnerability fixes and technology previews), please take a look at the <a href="https://www.ibm.com/docs/en/cloud-paks/cloud-pak-watson-aiops/3.4.1?topic=notes-whats-new">release notes</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84d0e960be4c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/new-capabilities-in-ibm-cloud-pak-for-watson-aiops-v3-4-84d0e960be4c">New capabilities in IBM Cloud Pak for AIOps v3.4</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Working with File Observers in WAIOps 3.1.1]]></title>
            <link>https://medium.com/ibm-watson-aiops/working-with-file-observers-in-waiops-3-1-1-ca76c257cc46?source=rss-88c89d5ae806------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca76c257cc46</guid>
            <category><![CDATA[ibm-cloud-pak]]></category>
            <category><![CDATA[observer]]></category>
            <category><![CDATA[topology]]></category>
            <category><![CDATA[watson-aiops]]></category>
            <category><![CDATA[ibm-watson]]></category>
            <dc:creator><![CDATA[Ricardo Olivieri]]></dc:creator>
            <pubDate>Fri, 08 Oct 2021 20:34:34 GMT</pubDate>
            <atom:updated>2021-10-13T21:23:19.502Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*_CjX9JpHFvEB1wzPiiGDVA.jpeg" /></figure><h4>Authors: <a href="https://medium.com/@ricardo.olivieri">Ricardo Olivieri</a>, <a href="https://medium.com/@mabubaker1947">Muhammad Abubaker</a></h4><p>In our previous <a href="https://medium.com/ibm-watson-aiops/working-with-rest-observers-in-watson-aiops-3-1-1-defcd1f43bc6">article</a>, we described how to use REST observers to feed topology information from your environment into IBM Watson AIOps (WAIOps). In this article, we introduce File observers, which can also be used for ingesting topology information. We will walk you through the steps for defining a File observer instance using the WAIOPs console and for defining the input topology file.</p><p><strong>Prerequisites</strong></p><ul><li>To get the most out of this article, you should have WAIOPs <strong>v3.1.1 </strong>successfully<strong> </strong>installed on your OpenShift cluster (<strong>v4.6</strong> or <strong>v4.7</strong>). You should also know your way around OpenShift.</li><li>You should expose the topology routes in your OpenShift cluster where Watson AIOps is installed. If you haven’t done this, please take a look at the Expose topology routes section in our previous <a href="https://medium.com/ibm-watson-aiops/working-with-rest-observers-in-watson-aiops-3-1-1-defcd1f43bc6">article</a>.</li><li>You should obtain the username and password credentials for the Topology (aka Agile Service Manager) user. You obtain these values by inspecting the evtmanager-topology-asm-credentials secret found in the namespace where you installed WAIOPs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o6BWFGE-9ttLAsc1fIdOUg.png" /></figure><p><strong>Access OpenAPI documentation for the File Observer</strong></p><p>Let’s first access the OpenAPI documentation for the File observer colocated with your WAIOPs v3.1.1 installation. From the OpenShift console, proceed to Networking &gt; Routes and search for the evtmanager-topology-file-observer route. Please take note of the value under the Location column for this route (e.g. https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p1R_OhhOUKKJaqAbUtAO-g.png" /></figure><p>To obtain the URL for the File observer OpenAPI page, append swagger to the Location value of your evtmanager-topology-file-observer route (e.g. <a href="https://evtmanager-topology.waiops.apps.wedge.cp.fyre.ibm.com/1.0/file-observer/swagger">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/swagger</a>). Navigating to this URL should take you to a page similar to the one captured in the screenshot below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SzAT5jYOWGRxLRjYxx5NRQ.png" /></figure><p>We recommend you explore the OpenAPI specification for the File observer to get acquainted with the REST API methods that are available. Note that you can also access the OpenAPI specification for the File observer on the official IBM WAIOPs <a href="https://www.ibm.com/docs/en/cloud-paks/cp-waiops/3.1.1?topic=apis-topology-file-observer">documentation</a>.</p><p><strong>Anatomy of input file for File Observer</strong></p><p>The main component types that make up an input file for File observer are Vertex V (nodes) and Edges E (connections between nodes). Lines in the file starting with a # character are ignored since they are treated as comments. For more information on the structure of a topology source file, please see <a href="https://www.ibm.com/docs/en/nasm/1.1.10?topic=ui-configuring-file-observer-jobs">Configuring File Observer jobs</a> and <a href="https://www.ibm.com/docs/en/nasm/1.1.10?topic=reference-properties">Properties</a>.</p><p><strong>Create and upload a simple topology file</strong></p><p>As an introductory example, we will define a simple topology comprised of one person and one department, where the person manages the department. The example file shown below captures such topology by utilizing two vertices connected by one edge.</p><pre># Vertex: components/nodes<br>V:{&quot;uniqueId&quot;:&quot;person1&quot;,&quot;name&quot;:&quot;person1&quot;,&quot;entityTypes&quot;:[&quot;person&quot;],&quot;matchTokens&quot;:[&quot;person1&quot;],&quot;tags&quot;:[&quot;my_app&quot;]}</pre><pre>V:{&quot;uniqueId&quot;:&quot;department1&quot;,&quot;name&quot;:&quot;department1&quot;,&quot;entityTypes&quot;:[&quot;organization&quot;],&quot;matchTokens&quot;:[&quot;department1&quot;],&quot;tags&quot;:[&quot;my_app&quot;]}</pre><pre># Edges: Relationships between vertices:<br>E:{&quot;_fromUniqueId&quot;:&quot;person1&quot;,&quot;_edgeType&quot;:&quot;manages&quot;,&quot;_toUniqueId&quot;:&quot;department1&quot;}</pre><p>The _edgeType element in the edge component defines the relationship (e.g. manages) between resources in a topology. For a list of all pre-defined edge types supported out-of-the-box, please see <a href="https://www.ibm.com/docs/en/nasm/1.1.10?topic=reference-edge-types">Edge types</a>.</p><p>Let’s upload to WAIOPs our example topology file using the following HTTP POST invocation:</p><pre>curl -k -u &quot;&lt;username&gt;:&lt;password&gt;&quot; -X POST --header &#39;Accept: application/json&#39; https://&lt;release-name&gt;.topology.&lt;namespace&gt;.&lt;domain&gt;/1.0/file-observer/files --form &#39;job_file=@&lt;topology-file&gt;&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39;</pre><p>where:</p><ul><li>release-name is the name of your deployment (e.g. evtmanager).</li><li>namespace is the namespace where WAIOPs was installed (e.g. cp4waiops).</li><li>domain is the domain name for your cluster.</li><li>topology-file is the full path on your local system of the topology file to upload. You should take note of the name of this file (e.g. department.topology) as we will need it while creating a File observer job instance.</li></ul><p>For example:</p><pre>curl -k -u &quot;evtmanager-topology-cp4waiops-user:&lt;password&gt;&quot; -X POST --header &#39;Accept: application/json&#39; <a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files</a> --form &#39;job_file=@&lt;path&gt;/department.topology&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39;</pre><p>If the upload was successful, you should not see a response from the execution of the command. Please note that if the file already exists, you <strong>cannot</strong> POST a new version of the file with the same name; attempting to do so throws the following error:</p><pre>{&quot;_error&quot;:{&quot;message&quot;:&quot;File already exists.&quot;,&quot;level&quot;:&quot;warning&quot;}}</pre><p>To update the topology file after you’ve uploaded it, you can use the same REST invocation but change the HTTP verb from POST to PUT:</p><pre>curl -k -u &quot;evtmanager-topology-cp4waiops-user:&lt;password&gt;&quot; -X PUT --header &#39;Accept: application/json&#39; <a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files</a> --form &#39;job_file=@&lt;path&gt;/department.topology&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39;</pre><p>After updating a topology file, you should see a response from the server similar to this:</p><p>[&quot;Updated successfully&quot;]</p><p><strong>Create and configure a File observer job</strong></p><p>After uploading the input topology file, you can create an instance of the File observer. On the WAIOPs console, click Data and tool integrations, proceed to the Advanced tab, click Manage observer jobs, and click the Add a new Job tile. You should then see several observer options to choose from (see screenshots below).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/1*BsgaS_Wuv7yl99ec4hwoCw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*z797Acxcoc8gf2Xrzlng2g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*lfVbvPwAWHVNP6MLRTRPCQ.png" /></figure><p>Choose the File observer tile and provide the configuration values shown below: FileObserverTest for Unique ID; for File Name, use the name of the file you uploaded previously (i.e. department.topology); and for Provider, use a name of your liking such as testApp.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7sJcs0Ra33fRTaoeQP5biw.png" /><figcaption>Creating new file observer job</figcaption></figure><p>Note that to create a File Observer job, you must first upload the topology file (e.g. department.topology) to WAIOPs (as we did in the previous section). Otherwise, there will be an error while creating the File observer job.</p><p>Click Save after entering the configuration values. You should then see a tile like the one shown below for your newly created File observer. Right after creating the File observer job, it will start executing and processing the uploaded topology file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gwOj6h98fdPWuPNlUGTY-Q.png" /><figcaption>FileObserverTest job is created</figcaption></figure><p>You can see the outcome of its execution by choosing the View history menu option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/444/1*tpTa3fUnft5iZ8eybUqm3A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*QsuRkS9RN_1bJbOJCWDFPA.png" /></figure><p>Using Topology viewer, you can visualize the topology configuration specified in the input file. You can use the keyword my_app to search for the topology (note that my_app is the <strong>tag</strong> value we assigned to both elements, person1 and department1, in the topology file).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*2vb3fvHt0obw6LngPCvQDg.png" /><figcaption>Search outcomes from Topology Viewer.</figcaption></figure><p>Clicking on either View topology button reveals the following topology diagram.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*-oXjdi2S4jn1dUwjROZkXw.png" /><figcaption>Topology diagram depicting person1 manages department1.</figcaption></figure><p>By default, File observers only run <strong>once</strong>, right after creation. To run them again, you have to manually kick off their execution. Having said that, note that you can schedule the execution of a File observer to occur at regular intervals (e.g. every hour).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lwSkLAe4KY9heijiNAbRbg.png" /><figcaption>Scheduling options for file observer job.</figcaption></figure><p><strong>Create and upload a more complex topology file</strong></p><p>Let’s now go over a second example which is more closely aligned to applications and servers. In this example, we have a topology file named application.topology that contains one server, host1, which is connected to four different applications: app1, app2, app3, and app4. Also, we define a relationship between app1 and app4, where app1depends (invokes) on app4.</p><pre># Vertex: components/nodes<br>V:{&quot;uniqueId&quot;:&quot;app1&quot;,&quot;name&quot;:&quot;app1&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app1&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app2&quot;,&quot;name&quot;:&quot;app2&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app2&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app3&quot;,&quot;name&quot;:&quot;app3&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app3&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;app4&quot;,&quot;name&quot;:&quot;app4&quot;,&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app4&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}<br>V:{&quot;uniqueId&quot;:&quot;host1&quot;,&quot;name&quot;:&quot;host1&quot;,&quot;entityTypes&quot;:[&quot;host&quot;],&quot;matchTokens&quot;:[&quot;host1&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;],&quot;connections&quot;:&quot;4&quot;}<br># Edges: Relationships between vertex:<br>E:{&quot;_fromUniqueId&quot;:&quot;host1&quot;,&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app1&quot;}<br>E:{&quot;_fromUniqueId&quot;:&quot;host1&quot;,&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app2&quot;}<br>E:{&quot;_fromUniqueId&quot;:&quot;host1&quot;,&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app3&quot;}<br>E:{&quot;_fromUniqueId&quot;:&quot;host1&quot;,&quot;_edgeType&quot;:&quot;connectedTo&quot;,&quot;_toUniqueId&quot;:&quot;app4&quot;}<br>E:{&quot;_fromUniqueId&quot;:&quot;app1&quot;,&quot;_edgeType&quot;:&quot;dependsOn&quot;,&quot;_toUniqueId&quot;:&quot;app4&quot;}</pre><p>Using the command below, let’s upload this new topology file to WAIOPs:</p><pre>curl -k -u &quot;evtmanager-topology-cp4waiops-user:&lt;password&gt;&quot; -X POST --header &#39;Accept: application/json&#39; <a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files</a> --form &#39;job_file=@&lt;path&gt;/<strong>application.topology</strong>&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39;</pre><p>Next, we will update the File Name value accordingly in the File Observer definition. Otherwise, the new topology that we just uploaded won’t be processed. On the WAIOPs console, click Data and tool integrations, proceed to the Advanced tab, click Manage observer jobs, and click on the three dots on the top right corner of the FileObserverTest job tile. Select View &amp; edit option and then update the File Name value in the definition.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yB8RdFzxgEABMS55nd3-ew.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Ewycd0KNDy1UgFvbBSuwg.png" /><figcaption>Updating File name in File Observer job’s Edit mode.</figcaption></figure><p>As before, once the topology definition is processed, we can see the corresponding resources and relationships using Topology viewer (for searching, use the my_awesome_app keyword since that is the <strong>tag</strong> assigned to the elements of this new topology):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*_U5XXx-yDrT-Qx1BdYASOw.png" /><figcaption>Search results from Topology Viewer.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/821/1*Vxtj1OIJK-Rx-VrIgIiUzA.png" /></figure><p>Let’s say that you intended to have uploaded the previous topology having app3 with a critical status. Replace the entry for app3 in the application.topology file with the following:</p><pre>V:{&quot;uniqueId&quot;:&quot;app3&quot;,&quot;name&quot;:&quot;app3&quot;,&quot;_status&quot;: [{&quot;status&quot;: &quot;CPU High&quot;,&quot;state&quot;: &quot;open&quot;,&quot;severity&quot;:&quot;critical&quot;}],&quot;entityTypes&quot;:[&quot;component&quot;],&quot;matchTokens&quot;:[&quot;app3&quot;],&quot;tags&quot;:[&quot;my_awesome_app&quot;]}</pre><p>Use then the following HTTP PUT curl command to upload the topology file:</p><pre>curl -k -u &quot;evtmanager-topology-cp4waiops-user:&lt;password&gt;&quot; -X PUT --header &#39;Accept: application/json&#39; <a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/file-observer/files</a> --form &#39;job_file=@&lt;path&gt;/<strong>application.topology</strong>&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39;</pre><p>To process the uploaded file, you should kick off the FileObserverTest job by clicking on the Run button (otherwise the changes won’t be shown on the topology view).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/578/1*fxchcJpf_qbab_WB_8Xj1A.png" /></figure><p>Once the FileObserverTest job finishes running, using Topology viewer, search again using the my_awesome_app keyword.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/721/1*bvhusJBGy3k8a9CgdhqesQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kFECmJNrW_JoEQnGBA3bSA.png" /></figure><p>To remove the critical status from app3, you can use a REST observer (for details on how to define and use REST observers, see our previous article <a href="https://medium.com/ibm-watson-aiops/working-with-rest-observers-in-watson-aiops-3-1-1-defcd1f43bc6">Working with REST Observers in Watson AIOps 3.1.1</a>). Once you have obtained the resource ID for app3, you can use a curl command similar to the following to clear its critical status:</p><pre>curl -k -u &quot;evtmanager-topology-cp4waiops-user:&lt;password&gt;&quot; -X PUT --header &#39;Content-Type: application/json&#39; --header &#39;Accept: application/json&#39; --header &#39;X-TenantID: cfd95b7e-3bc7-4006-a4a8-a73a79c71255&#39; --header &#39;JobId: RESTListenerTest&#39; -d &#39;{<br>  &quot;uniqueId&quot;: &quot;app3&quot;,<br>  &quot;_status&quot;: [<br>    {<br>      &quot;status&quot;: &quot;CPU High&quot;,<br>      &quot;state&quot;: &quot;<strong>clear</strong>&quot;<br>    }<br>  ]<br>}&#39; &#39;<a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/topology/resources/yR0bGz7hRs2QWN7GKAZEWw&#39;">https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/topology/resources/</a>ISDFYLXkTYWe5F7VFF1RVw<a href="https://evtmanager-topology.cp4waiops.apps.capstan.cp.fyre.ibm.com/1.0/topology/resources/yR0bGz7hRs2QWN7GKAZEWw&#39;">&#39;</a></pre><p>Reload the topology and you should now see that app3 is <strong>no</strong> longer in a critical state.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X-1476hZz4wsf84z_oZOAA.png" /></figure><p><strong>Conclusion</strong></p><p>In this article, we discussed how to leverage File observers to feed topology information into WAIOPs. We went over several examples for defining resources and relationships between those resources. File observers are an excellent choice for uploading a large topology definition into WAIOPs. As with REST observers, File observers are great too for ingesting topology information when there is no out of the box topology observer. Finally, as shown in the article, after processing a topology file with a File observer, you can use a REST observer to augment (e.g. update the status of an element) the topology.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca76c257cc46" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ibm-watson-aiops/working-with-file-observers-in-waiops-3-1-1-ca76c257cc46">Working with File Observers in WAIOps 3.1.1</a> was originally published in <a href="https://medium.com/ibm-watson-aiops">IBM IT Automation and AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>