David Solis’ Post

Outcomes are essential for Advisory. Our ITOps Tech. Advisory Services... Advises, Architects, Solutions, and Implements those solutions, removing the traditional gap between standalone Advisory and execution teams. Recent Advisory outcome wins, An Observability/AIOps Advisory led MVP recently saved one client over 1.4M in revenue downtime cost avoidance in three months time. (client outcome) A Generative AI for ITOps Advisory Assessment helped another client team discover 10 thousand hours a month of reoccurring productivity savings in ITOps utilizing a GenAI future state roadmap, dataplane strategy, and a value-aligned implementation plan. (Precursor business case to automation and augmentation outcome)

Check out this blog from my colleague Dave Stewart Using your business or market terminology to explain EA and Business architecture concepts to stakeholders. And of course keeping things simple #enterprisearchitecture #modelling #MooD

𝑬𝒎𝒃𝒓𝒂𝒄𝒊𝒏𝒈 𝒕𝒉𝒆 𝑫𝒆𝒑𝒆𝒏𝒅𝒆𝒏𝒄𝒚 𝑰𝒏𝒗𝒆𝒓𝒔𝒊𝒐𝒏 𝑷𝒓𝒊𝒏𝒄𝒊𝒑𝒍𝒆 (𝑫𝑰𝑷) 𝒊𝒏 𝑴𝒂𝒄𝒉𝒊𝒏𝒆 𝑳𝒆𝒂𝒓𝒏𝒊𝒏𝒈-𝑩𝒂𝒔𝒆𝒅 𝑨𝑷𝑰𝒔 The Dependency Inversion Principle, one of the SOLID principles of object-oriented design, promotes a flexible and decoupled architecture by encouraging high-level modules to depend on abstractions rather than concrete implementations. This is particularly crucial in machine learning APIs, where models and data processing pipelines frequently evolve. Here’s how embracing DIP can transform your ML-based APIs: Enhanced Modularity: By depending on abstractions (interfaces), different components of your API can evolve independently. This modularity ensures that updates to machine learning models or data processing logic do not necessitate widespread changes across the system. Improved Testability: With DIP, components can be easily mocked or stubbed, leading to more effective and isolated unit tests. This means more reliable testing processes and faster iteration cycles, which are essential in the fast-paced ML landscape. Greater Flexibility: DIP allows for seamless integration of new models or algorithms. By adhering to interfaces, new implementations can be swapped in with minimal disruption, facilitating continuous improvement and experimentation. Decoupled Systems: High-level business logic is insulated from low-level data handling specifics, resulting in a more robust and adaptable system architecture. 𝑩𝒚 𝒊𝒏𝒕𝒆𝒈𝒓𝒂𝒕𝒊𝒏𝒈 𝒕𝒉𝒆 𝑫𝒆𝒑𝒆𝒏𝒅𝒆𝒏𝒄𝒚 𝑰𝒏𝒗𝒆𝒓𝒔𝒊𝒐𝒏 𝑷𝒓𝒊𝒏𝒄𝒊𝒑𝒍𝒆, 𝒘𝒆 𝒏𝒐𝒕 𝒐𝒏𝒍𝒚 𝒇𝒖𝒕𝒖𝒓𝒆-𝒑𝒓𝒐𝒐𝒇 𝒐𝒖𝒓 𝒎𝒂𝒄𝒉𝒊𝒏𝒆 𝒍𝒆𝒂𝒓𝒏𝒊𝒏𝒈 𝑨𝑷𝑰𝒔 𝒃𝒖𝒕 𝒂𝒍𝒔𝒐 𝒇𝒐𝒔𝒕𝒆𝒓 𝒂 𝒅𝒆𝒗𝒆𝒍𝒐𝒑𝒎𝒆𝒏𝒕 𝒆𝒏𝒗𝒊𝒓𝒐𝒏𝒎𝒆𝒏𝒕 𝒄𝒐𝒏𝒅𝒖𝒄𝒊𝒗𝒆 𝒕𝒐 𝒊𝒏𝒏𝒐𝒗𝒂𝒕𝒊𝒐𝒏 𝒂𝒏𝒅 𝒂𝒈𝒊𝒍𝒊𝒕𝒚. 𝑳𝒆𝒕'𝒔 𝒆𝒎𝒃𝒓𝒂𝒄𝒆 𝑫𝑰𝑷 𝒕𝒐 𝒃𝒖𝒊𝒍𝒅 𝒓𝒆𝒔𝒊𝒍𝒊𝒆𝒏𝒕, 𝒔𝒄𝒂𝒍𝒂𝒃𝒍𝒆, 𝒂𝒏𝒅 𝒎𝒂𝒊𝒏𝒕𝒂𝒊𝒏𝒂𝒃𝒍𝒆 𝑴𝑳 𝒔𝒚𝒔𝒕𝒆𝒎𝒔. #MachineLearning #SoftwareDesign #SOLIDPrinciples #APIDevelopment #TechInnovation #BestPractices #DependencyInversionPrinciple

Building AI Agents? You're probably starting at the wrong layer. (A perspective after building agent systems for 100+ implementations) Let me explain why many of us are approaching agent architecture backwards: 1. The Current Approach - Start with workflow-specific agents - Buy pre-built solutions - Add agents one by one - Hope they work together somehow 2. The Foundation Issue - Data lives in separate platforms - Agents lack full context - No unified data architecture - Limited scalability potential 3. A Better Architecture - Start with a master contextual database - Build foundational agents first - Create workflow agents last - Enable natural system growth Here's why this matters: Your data is your foundation. Your architecture determines your ceiling. Your approach defines your future scale. Instead of rushing to solutions, consider this path: 1. Build your contextual database first - Centralize your business data - Create proper vector embeddings - Enable real-time updates 2. Develop foundation agents - Connect to your core platforms - Create base tool interfaces - Establish clear protocols 3. Only then build workflow agents - Leverage your foundation - Maintain consistent architecture - Scale naturally The truth is, no one wants to start with infrastructure. It's not exciting. It doesn't give quick wins. But it's the difference between building for now and building for the future. Would you rather explain quick wins today, or sustained success tomorrow? Let's build things right.

LlamaIndex Workflows takes a new approach, with implications for developers building agentic systems. Workflows leverages an event-based architecture instead of the directed acyclic graph approach used by traditional chains and pipelines. Workflows are good at: 🧗 Complicated agents, especially those that often loop back to previous steps 🧠 Dynamic applications that use many optional and default variable values While graphs are great at: 📈 Linear applications with rigid paths (i.e. defining a workflow for an agent that simply calls an LLM and performs some form of structured data extraction may only add unnecessary complexity). Workflows can be traced using Arize Phoenix, which also has an experiments feature that can help during testing and evaluation. Workflows can be evaluated using the same approach as evaluating any agent. Agents are typically complex enough that evaluating full runthroughs of the app won’t tell you much. Instead, it pays to look to evaluate each step of the app independently. More on Phoenix’s integration with LlamaIndex Workflows and a code-along example for tracing, iterating, and evaluating your agent in this blog by John Gilhuly with a demo by Nicholas Luzio: https://lnkd.in/ga_NWUPn

We love this blog post from Arize AI showing the power of building agents with Workflows, and using Phoenix to observe and debug them. Key points from the post: ➡️ Workflows use an event-based architecture, allowing for more flexible and cyclical agent designs compared to directed acyclic graphs. ➡️ Steps in Workflows can receive and emit events, access shared context, and easily handle complex tasks with branching paths or loops. ➡️ Arize Phoenix integration enables visualization of step-by-step invocations in Workflows without extensive logging code. The post shares code snippets for setting up tracing with Arize Phoenix and shows how to use its Experiments feature for easier evaluation.

Interested in learning how to trace agentic systems? Checkout our tutorial on using Phoenix's integration with LlamaIndex to do just that! Follow along, and reach out if you have any questions on how you can take your LLM apps to the next level with Arize Phoenix.

Please join us for an exclusive webinar as we introduce the next release of the AveriSource Platform™, now supercharged with cutting-edge Generative AI (GenAI) capabilities. This exciting update empowers your team to significantly accelerate application assessments and streamline the documentation of business requirements like never before. In this webinar, you'll get a first look at how AveriSource’s new GenAI features can transform your modernization planning and workflow, reducing the time and effort needed to understand, analyze, and document complex legacy applications running on mainframe and midrange platforms. Discover how these latest advancements can help your team: • Automate and accelerate the accuracy of application assessments. • Quickly generate comprehensive business requirements documentation—in just minutes! • Expedite modernization project timelines while maintaining the highest standards of quality. Whether you’re a developer, business analyst, or architect, this event is your opportunity to stay ahead of the curve and harness the power of GenAI to drive efficiency and innovation at scale within your organization. Don’t miss this chance to see the future of AI-powered application modernization. Interested in learning more? Tune in at 2 p.m. ET on Thursday, October 17th to start your modernization journey.

Simplifying accelerators with an atomic design approach "Our accelerator is flexible - use it all or just bits and pieces!" Sounds great in theory, but for many customers, it's like being handed a toolbox without knowing what each tool does. Here is how the atomic design approach can turn confusion into clarity: Atoms (Basic Building Blocks): • UI Components: Buttons, input fields, icons • API Endpoints: Product API, User API, Order API • Database Tables: User table, Product table, Order table • Infrastructure Components: Load balancer, cache, message queue Molecules (Functional Groups): • Data Models: User model, Product model, Order model • Feature Modules: Product listing, shopping cart, checkout process • Service Integrations: Payment gateway, shipping provider, analytics service • Deployment Scripts: Container orchestration, CI/CD pipeline, monitoring setup Organisms (Complex Components): • Backend: API gateway, microservices, databases • Frontend: Web app, mobile app, admin dashboard • Infrastructure: Cloud services, network configuration, security systems Template (Accelerator): The accelerator itself serves as the template, providing a pre-configured set of atoms, molecules, and organisms that can be customized and combined. Page (Customer Project): The actual customer project is represented as a page, which is a specific instance of the template with customized components and real content. ---------------------------------- In this structure: • Atoms are the smallest, indivisible components of the system. • Molecules combine atoms to create functional units. • Organisms are complex, standalone parts of the application that combine multiple molecules and atoms. This approach allows customers to: • Use the entire accelerator as a starting point (full template). • Pick and choose specific organisms (e.g., just the Frontend or Backend). • Customize at the molecule level (e.g., swap out the payment gateway). • Fine-tune individual atoms for highly specific requirements. Does this approach make sense?

AI-driven modernization is a powerful strategy that delivers efficient results, optimizes processes, ensures greater efficiency, and accelerates value delivery while reducing costs. In this article, you will discover the benefits of AI-driven modernization for your business: https://lnkd.in/diJK2-B4