Speaking to your Community

Embarking on my journey as a community engineer practically 20 years in the past, I used to be among the many early adopters who acknowledged the transformative potential of community automation. In 2015, after attending Cisco Dwell in San Diego, I gained a brand new appreciation of the realm of the potential. Leveraging instruments like Ansible and Cisco pyATS, I started to streamline processes and improve efficiencies inside community operations, setting a basis for what would turn out to be a career-long pursuit of innovation. This preliminary foray into automation was not nearly simplifying repetitive duties; it was about envisioning a future the place networks might be extra resilient, adaptable, and clever. As I navigated by the complexities of community methods, these applied sciences grew to become indispensable allies, serving to me to not solely handle but additionally to anticipate the wants of more and more refined networks.

In recent times, my exploration has taken a pivotal flip with the arrival of generative AI, marking a brand new chapter within the story of community automation. The mixing of synthetic intelligence into community operations has opened up unprecedented potentialities, permitting for even larger ranges of effectivity, predictive evaluation, and decision-making capabilities. This weblog, accompanying the CiscoU Tutorial, delves into the cutting-edge intersection of AI and community automation, highlighting my experiences with Docker, LangChain, Streamlit, and, after all, Cisco pyATS. It’s a mirrored image on how the panorama of community engineering is being reshaped by AI, remodeling not simply how we handle networks, however how we envision their progress and potential within the digital age. By means of this narrative, I goal to share insights and sensible data on harnessing the facility of AI to reinforce the capabilities of community automation, providing a glimpse into the way forward for community operations.

Within the spirit of contemporary software program deployment practices, the answer I architected is encapsulated inside Docker, a platform that packages an software and all its dependencies in a digital container that may run on any Linux server. This encapsulation ensures that it really works seamlessly in several computing environments. The center of this dockerized answer lies inside three key recordsdata: the Dockerfile, the startup script, and the docker-compose.yml.

The Dockerfile serves because the blueprint for constructing the appliance’s Docker picture. It begins with a base picture, ubuntu:newest, making certain that every one the operations have a stable basis. From there, it outlines a sequence of instructions that put together the atmosphere:

FROM ubuntu:newest

# Set the noninteractive frontend (helpful for automated builds)
ARG DEBIAN_FRONTEND=noninteractive

# A sequence of RUN instructions to put in needed packages
RUN apt-get replace && apt-get set up -y wget sudo ...

# Python, pip, and important instruments are put in
RUN apt-get set up python3 -y && apt-get set up python3-pip -y ...

# Particular Python packages are put in, together with pyATS[full]
RUN pip set up pyats[full]

# Different utilities like dos2unix for script compatibility changes
RUN sudo apt-get set up dos2unix -y

# Set up of LangChain and associated packages
RUN pip set up -U langchain-openai langchain-community ...

# Set up Streamlit, the online framework
RUN pip set up streamlit

Every command is preceded by an echo assertion that prints out the motion being taken, which is extremely useful for debugging and understanding the construct course of because it occurs.

The startup.sh script is an easy but essential element that dictates what occurs when the Docker container begins:

cd streamlit_langchain_pyats
streamlit run chat_with_routing_table.py

It navigates into the listing containing the Streamlit app and begins the app utilizing streamlit run. That is the command that truly will get our app up and working throughout the container.

Lastly, the docker-compose.yml file orchestrates the deployment of our Dockerized software. It defines the companies, volumes, and networks to run our containerized software:

model: '3'
companies:
 streamlit_langchain_pyats:
  picture: [Docker Hub image]
  container_name: streamlit_langchain_pyats
  restart: all the time
  construct:
   context: ./
   dockerfile: ./Dockerfile
  ports:
   - "8501:8501"

This docker-compose.yml file makes it extremely straightforward to handle the appliance lifecycle, from beginning and stopping to rebuilding the appliance. It binds the host’s port 8501 to the container’s port 8501, which is the default port for Streamlit functions.

Collectively, these recordsdata create a strong framework that ensures the Streamlit software — enhanced with the AI capabilities of LangChain and the highly effective testing options of Cisco pyATS — is containerized, making deployment and scaling constant and environment friendly.

The journey into the realm of automated testing begins with the creation of the testbed.yaml file. This YAML file isn’t just a configuration file; it’s the cornerstone of our automated testing technique. It incorporates all of the important details about the units in our community: hostnames, IP addresses, system sorts, and credentials. However why is it so essential? The testbed.yaml file serves as the only supply of fact for the pyATS framework to know the community it is going to be interacting with. It’s the map that guides the automation instruments to the appropriate units, making certain that our scripts don’t get misplaced within the huge sea of the community topology.

Pattern testbed.yaml

---
units:
  cat8000v:
    alias: "Sandbox Router"
    kind: "router"
    os: "iosxe"
    platform: Cat8000v
    credentials:
      default:
        username: developer
        password: C1sco12345
    connections:
      cli:
        protocol: ssh
        ip: 10.10.20.48
        port: 22
        arguments:
        connection_timeout: 360

With our testbed outlined, we then flip our consideration to the _job file. That is the conductor of our automation orchestra, the management file that orchestrates all the testing course of. It hundreds the testbed and the Python take a look at script into the pyATS framework, setting the stage for the execution of our automated assessments. It tells pyATS not solely what units to check but additionally the way to take a look at them, and in what order. This stage of management is indispensable for working complicated take a look at sequences throughout a spread of community units.

Pattern _job.py pyATS Job

import os
from genie.testbed import load

def foremost(runtime):

    # ----------------
    # Load the testbed
    # ----------------
    if not runtime.testbed:
        # If no testbed is supplied, load the default one.
        # Load default location of Testbed
        testbedfile = os.path.be part of('testbed.yaml')
        testbed = load(testbedfile)
    else:
        # Use the one supplied
        testbed = runtime.testbed

    # Discover the placement of the script in relation to the job file
    testscript = os.path.be part of(os.path.dirname(__file__), 'show_ip_route_langchain.py')

    # run script
    runtime.duties.run(testscript=testscript, testbed=testbed)

Then comes the pièce de résistance, the Python take a look at script — let’s name it capture_routing_table.py. This script embodies the intelligence of our automated testing course of. It’s the place we’ve distilled our community experience right into a sequence of instructions and parsers that work together with the Cisco IOS XE units to retrieve the routing desk info. However it doesn’t cease there; this script is designed to seize the output and elegantly remodel it right into a JSON construction. Why JSON, you ask? As a result of JSON is the lingua franca for information interchange, making the output from our units available for any variety of downstream functions or interfaces which may must devour it. In doing so, we’re not simply automating a activity; we’re future-proofing it.

Excerpt from the pyATS script

    @aetest.take a look at
    def get_raw_config(self):
        raw_json = self.system.parse("present ip route")

        self.parsed_json = {"information": raw_json}

    @aetest.take a look at
    def create_file(self):
        with open('Show_IP_Route.json', 'w') as f:
            f.write(json.dumps(self.parsed_json, indent=4, sort_keys=True))

By focusing solely on pyATS on this part, we lay a robust basis for community automation. The testbed.yaml file ensures that our script is aware of the place to go, the _job file provides it the directions on what to do, and the capture_routing_table.py script does the heavy lifting, turning uncooked information into structured data. This method streamlines our processes, making it potential to conduct complete, repeatable, and dependable community testing at scale.

Enhancing AI Conversational Fashions with RAG and Community JSON: A Information

Within the ever-evolving discipline of AI, conversational fashions have come a great distance. From easy rule-based methods to superior neural networks, these fashions can now mimic human-like conversations with a exceptional diploma of fluency. Nonetheless, regardless of the leaps in generative capabilities, AI can generally stumble, offering solutions which are nonsensical or “hallucinated” — a time period used when AI produces info that isn’t grounded in actuality. One technique to mitigate that is by integrating Retrieval-Augmented Technology (RAG) into the AI pipeline, particularly together with structured information sources like community JSON.

What’s Retrieval-Augmented Technology (RAG)?

Retrieval-Augmented Technology is a cutting-edge method in AI language processing that mixes one of the best of two worlds: the generative energy of fashions like GPT (Generative Pre-trained Transformer) and the precision of retrieval-based methods. Basically, RAG enhances a language mannequin’s responses by first consulting a database of knowledge. The mannequin retrieves related paperwork or information after which makes use of this context to tell its generated output.

The RAG Course of

The method sometimes includes a number of key steps:

• Retrieval: When the mannequin receives a question, it searches by a database to search out related info.
• Augmentation: The retrieved info is then fed into the generative mannequin as further context.
• Technology: Armed with this context, the mannequin generates a response that’s not solely fluent but additionally factually grounded within the retrieved information.

The Position of Community JSON in RAG

Community JSON refers to structured information within the JSON (JavaScript Object Notation) format, usually utilized in community communications. Integrating community JSON with RAG serves as a bridge between the generative mannequin and the huge quantities of structured information obtainable on networks. This integration will be vital for a number of causes:

• Knowledge-Pushed Responses: By pulling in community JSON information, the AI can floor its responses in actual, up-to-date info, decreasing the danger of “hallucinations.”
• Enhanced Accuracy: Entry to a wide selection of structured information means the AI’s solutions will be extra correct and informative.
• Contextual Relevance: RAG can use community JSON to know the context higher, resulting in extra related and exact solutions.

Why Use RAG with Community JSON?

Let’s discover why one may select to make use of RAG in tandem with community JSON by a simplified instance utilizing Python code:

• Supply and Load: The AI mannequin begins by sourcing information, which might be community JSON recordsdata containing info from numerous databases or the web.
• Remodel: The info may endure a metamorphosis to make it appropriate for the AI to course of — for instance, splitting a big doc into manageable chunks.
• Embed: Subsequent, the system converts the reworked information into embeddings, that are numerical representations that encapsulate the semantic which means of the textual content.
• Retailer: These embeddings are then saved in a retrievable format.
• Retrieve: When a brand new question arrives, the AI makes use of RAG to retrieve essentially the most related embeddings to tell its response, thus making certain that the reply is grounded in factual information.

By following these steps, the AI mannequin can drastically enhance the standard of the output, offering responses that aren’t solely coherent but additionally factually right and extremely related to the person’s question.

class ChatWithRoutingTable:
    def __init__(self):
        self.conversation_history = []
        self.load_text()
        self.split_into_chunks()
        self.store_in_chroma()
        self.setup_conversation_memory()
        self.setup_conversation_retrieval_chain()

    def load_text(self):
        self.loader = JSONLoader(
            file_path='Show_IP_Route.json',
            jq_schema=".information[]",
            text_content=False
        )
        self.pages = self.loader.load_and_split()

    def split_into_chunks(self):
        # Create a textual content splitter
        self.text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=100,
            length_function=len,
        )
        self.docs = self.text_splitter.split_documents(self.pages)

    def store_in_chroma(self):
        embeddings = OpenAIEmbeddings()
        self.vectordb = Chroma.from_documents(self.docs, embedding=embeddings)
        self.vectordb.persist()

    def setup_conversation_memory(self):
        self.reminiscence = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

    def setup_conversation_retrieval_chain(self):
        self.qa = ConversationalRetrievalChain.from_llm(llm, self.vectordb.as_retriever(search_kwargs={"okay": 10}), reminiscence=self.reminiscence)

    def chat(self, query):
        # Format the person's immediate and add it to the dialog historical past
        user_prompt = f"Person: {query}"
        self.conversation_history.append({"textual content": user_prompt, "sender": "person"})

        # Format all the dialog historical past for context, excluding the present immediate
        conversation_context = self.format_conversation_history(include_current=False)

        # Concatenate the present query with dialog context
        combined_input = f"Context: {conversation_context}nQuery: {query}"

        # Generate a response utilizing the ConversationalRetrievalChain
response = self.qa.invoke(combined_input)

        # Extract the reply from the response
reply = response.get('reply', 'No reply discovered.')

        # Format the AI's response
        ai_response = f"Cisco IOS XE: {reply}"
        self.conversation_history.append({"textual content": ai_response, "sender": "bot"})

        # Replace the Streamlit session state by appending new historical past with each person immediate and AI response
        st.session_state['conversation_history'] += f"n{user_prompt}n{ai_response}"

        # Return the formatted AI response for fast show
        return ai_response

Conclusion

The mixing of RAG with community JSON is a strong technique to supercharge conversational AI. It results in extra correct, dependable, and contextually conscious interactions that customers can belief. By leveraging the huge quantities of obtainable structured information, AI fashions can step past the constraints of pure era and in direction of a extra knowledgeable and clever conversational expertise.

Associated sources

Share: