DevNetSecOps

ciscodev

# Windsurf IDE: The Future of Agentic AI Development

In the rapidly evolving landscape of AI-powered development tools, Windsurf (formerly Codeium) has emerged as a revolutionary IDE that's pushing the boundaries of what's possible in code creation. Let's explore what makes Windsurf unique, particularly its agentic features and Cascade technology, and how it stacks up against other AI-capable IDEs.

## What Makes Windsurf Truly Agentic?

Windsurf isn't just another AI-assisted IDE—it's the first truly agentic development environment. But what does "agentic" actually mean in this context?

Traditional AI coding assistants like GitHub Copilot operate primarily as "co-pilots," providing suggestions that developers must explicitly request and manually integrate. In contrast, Windsurf combines collaborative capabilities with autonomous agency, allowing the AI to:

1. **Anticipate needs** rather than just respond to explicit requests
2. **Take initiative** on complex tasks across multiple files
3. **Maintain context awareness** throughout the entire development process
4. **Learn from your workflow** to become a more effective partner

Windsurf represents a paradigm shift from "AI as assistant" to "AI as agent"—a partner that can both collaborate and operate autonomously when needed.

## Cascade: The Heart of Windsurf's Intelligence

At the core of Windsurf's agentic capabilities is Cascade, a revolutionary AI technology that transforms how developers interact with their code. Unlike traditional chat interfaces that require constant context-setting, Cascade maintains deep awareness of:

- Your entire codebase structure and relationships
- Your current working context across multiple files
- Your recent actions and editing patterns
- Your preferences and coding style

Cascade combines this contextual intelligence with powerful tools including:

- **Multi-file editing**: Cascade can reason about and modify multiple files simultaneously, understanding dependencies and maintaining consistency.
- **Terminal integration**: The AI can suggest and execute commands directly in the terminal without breaking your flow.
- **Visual understanding**: Upload images of designs or wireframes, and Cascade can implement them directly in code.
- **Memory and learning**: Cascade remembers important aspects of your codebase and workflow, creating a more personalized experience over time.

Perhaps most impressively, Cascade maintains what the Windsurf team calls a "flow state" between developer and AI—a continuous stream of shared awareness that feels like a true mind-meld experience.

## See Windsurf in Action

To truly appreciate the capabilities of Windsurf and its Cascade technology, you need to see it in action. Check out this official demonstration video:

<iframe 
 width="100%" 
 height="400" 
 src="https://www.youtube.com/embed/C_D8V9odBQ8" 
 title="Windsurf IDE: The Ultimate AI Coding Assistant" 
 frameborder="0" 
 allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
 allowfullscreen>
</iframe>

## Windsurf vs. Other AI-Capable IDEs

How does Windsurf compare to other popular AI-powered development environments? Let's break it down:

### Windsurf vs. Cursor

**Foundation**:
- Both are built as VS Code forks, offering familiar interfaces
- Cursor emerged earlier but Windsurf has rapidly closed the gap with innovative features

**Code Completion**:
- Windsurf's "Supercomplete" offers predictive, context-aware suggestions that go beyond simple line completion
- Cursor's tab completion excels at multi-line suggestions with strong type support

**Collaboration**:
- Cursor offers powerful real-time session sharing for team collaboration
- Windsurf focuses more on individual developer efficiency with perfect workspace sync

**User Experience**:
- Windsurf generally offers a cleaner, more refined UI compared to Cursor
- Windsurf's write vs. chat mode toggle provides flexibility based on your current needs

**Performance**:
- In head-to-head tests, Windsurf consistently outperforms Cursor in speed and accuracy
- Windsurf shows particular strength in file location and context-awareness when working with custom components

**Pricing**:
- Windsurf: Free tier, Pro plan at $15/month, Pro Ultimate at $60/month
- Cursor: Free 'Hobby' plan, Pro at $20/month, Business at $40/user/month

### Windsurf vs. GitHub Copilot

**Integration**:
- Copilot integrates with various IDEs including VS Code, IntelliJ, and Neovim
- Windsurf is a standalone IDE with its own unique capabilities

**AI Approach**:
- Copilot focuses on inline suggestions and is more reactive than agentic
- Windsurf's Cascade provides a more proactive, context-aware experience

**Multi-file Handling**:
- Copilot has limited awareness across multiple files
- Windsurf excels at multi-file operations with comprehensive understanding

**Pricing**:
- Copilot starts at $10/month for individual users
- Windsurf offers a more diverse pricing structure with free tier options

## Who Should Use Windsurf?

Windsurf appears particularly well-suited for:

1. **Beginners**: The agentic approach guides users through coding tasks with less need for explicit context-setting
2. **Individual developers**: The fluid, personalized workflow enhances productivity for solo work
3. **Framework-heavy projects**: Windsurf's perfect workspace sync excels with complex frameworks
4. **Design implementation**: The visual understanding capabilities make translating designs to code easier

Meanwhile, Cursor might be preferred by teams requiring real-time collaboration, while Copilot remains a solid choice for developers who want AI assistance within their existing IDE setup.

## Conclusion: The Future of AI-Assisted Development

Windsurf represents a significant step forward in the evolution of AI-assisted coding. Its agentic approach and Cascade technology offer a glimpse into a future where the boundary between human and AI collaborators becomes increasingly fluid.

While tools like Cursor and Copilot continue to innovate in important ways, Windsurf's focus on creating a true "flow state" between developer and AI points toward the most likely direction for future development environments.

As AI capabilities continue to advance, we can expect the line between suggestion and agency to blur further. Windsurf is at the forefront of this transformation, redefining our expectations of what an IDE can be in the age of artificial intelligence.

Have you tried Windsurf or other AI-powered development environments? Share your experiences in the comments below!

Exploring Windsurf's agentic features, Cascade technology, and how it compares to other AI-powered IDEs like Cursor and GitHub Copilot

Windsurf IDE: The Future of Agentic AI Development

# Cisco's Leaf-Spine Architecture for AI Workloads

Modern AI workloads demand exceptional network performance, low latency, and high reliability. Cisco's leaf-spine architecture provides an ideal foundation for AI and machine learning infrastructure, enabling high-bandwidth, low-latency communication between GPU clusters and storage systems.

## Leaf-Spine Network Topology for AI/ML Workloads

The following diagram illustrates a Cisco-based leaf-spine architecture optimized for AI and machine learning workloads:

<Mermaid chart={`
flowchart TD
 %% Style definitions
 style SP1 fill:#006699,color:white,stroke:#004466,stroke-width:2px
 style SP2 fill:#006699,color:white,stroke:#004466,stroke-width:2px

 style LS1 fill:#00bceb,color:white,stroke:#0099cc,stroke-width:2px
 style LS2 fill:#00bceb,color:white,stroke:#0099cc,stroke-width:2px
 style LS3 fill:#00bceb,color:white,stroke:#0099cc,stroke-width:2px
 style LS4 fill:#00bceb,color:white,stroke:#0099cc,stroke-width:2px

 style SRV1 fill:#ffffff,stroke:#999999,stroke-width:1px
 style SRV2 fill:#ffffff,stroke:#999999,stroke-width:1px

 style STG1 fill:#ffbe00,color:black,stroke:#e68a00,stroke-width:2px
 style STG2 fill:#ffbe00,color:black,stroke:#e68a00,stroke-width:2px

 style GPU1 fill:#93c47d,color:black,stroke:#6aa84f,stroke-width:2px
 style GPU2 fill:#93c47d,color:black,stroke:#6aa84f,stroke-width:2px

 %% Spine Layer
 SP1["Cisco Nexus 9316D-GX Spine Switch 1"]
 SP2["Cisco Nexus 9316D-GX Spine Switch 2"]

 %% Leaf Layer
 LS1["Cisco Nexus 93180YC-FX Leaf Switch 1"]
 LS2["Cisco Nexus 93180YC-FX Leaf Switch 2"]
 LS3["Cisco Nexus 93180YC-FX Leaf Switch 3"]
 LS4["Cisco Nexus 93180YC-FX Leaf Switch 4"]

 %% AI Compute Nodes
 GPU1["NVIDIA GPU Cluster 1 with Cisco UCS X-Series"]
 GPU2["NVIDIA GPU Cluster 2 with Cisco UCS X-Series"]

 %% Storage Systems
 STG1["High-Performance Flash Storage"]
 STG2["Scale-Out NAS Storage"]

 %% General Compute
 SRV1["Cisco UCS Compute Node 1"]
 SRV2["Cisco UCS Compute Node 2"]

 %% Connections between Spine and Leaf
 SP1 --- LS1
 SP1 --- LS2
 SP1 --- LS3
 SP1 --- LS4
 SP2 --- LS1
 SP2 --- LS2
 SP2 --- LS3
 SP2 --- LS4

 %% Connections to GPU Clusters
 LS1 --- GPU1
 LS2 --- GPU1
 LS3 --- GPU2
 LS4 --- GPU2

 %% Connections to Storage
 LS1 --- STG1
 LS2 --- STG1
 LS3 --- STG2
 LS4 --- STG2

 %% Connections to Compute
 LS2 --- SRV1
 LS3 --- SRV2
`} />

## Key Components

### Spine Layer
- **Cisco Nexus 9316D-GX Switches**: Provide high-density 400G connectivity, enabling ultra-low latency and high-bandwidth connectivity between leaf switches
- **Non-blocking Architecture**: Ensures any-to-any connectivity across the data center fabric

### Leaf Layer
- **Cisco Nexus 93180YC-FX Switches**: Offer high-density 10/25G connectivity to servers with 100G uplinks to the spine
- **VXLAN EVPN**: Enables scalable Layer 2 and Layer 3 connectivity across the fabric

### AI Compute
- **Cisco UCS X-Series with NVIDIA GPUs**: Provides the computational power needed for large AI models
- **RoCE (RDMA over Converged Ethernet)**: Enables high-performance, low-latency GPU-to-GPU communication

### Storage
- **High-Performance Flash Storage**: Provides high IOPS and low latency for AI training data
- **Scale-Out NAS**: Offers high throughput for large datasets

## Benefits for AI Workloads

1. **Predictable Latency**: Every device is the same distance (number of hops) from any other device
2. **Linear Scalability**: Add leaf switches as compute or storage needs grow
3. **High Bandwidth**: Non-blocking fabric ensures maximum throughput for GPU-to-GPU communication
4. **Redundancy**: Dual-homed connections provide path diversity and high availability

## Design Considerations

- **Oversubscription Ratio**: Typically designed with 2:1 or 3:1 oversubscription for AI workloads
- **Traffic Engineering**: QoS policies to prioritize AI training traffic
- **Telemetry**: Cisco Nexus Insights provides real-time visibility into network performance
- **Automation**: Cisco DCNM/Nexus Dashboard enables automated fabric deployment and management

This architecture provides the foundation for a high-performance infrastructure capable of supporting the most demanding AI and machine learning workloads, from training to inference.

Visualizing Cisco's leaf-spine data center design optimized for AI and machine learning workloads

Cisco's Leaf-Spine Architecture for AI Workloads


# Building a Chat Application with Streamlit, SQLite, and xAI's Grok API

This tutorial walks you through creating a chat application using Streamlit, SQLite for conversation storage, and xAI's Grok API for AI responses. The app allows users to start new conversations, view past conversations, and interact with Grok, an AI assistant.

## Prerequisites

- Python 3.8+
- Streamlit (`pip install streamlit`)
- OpenAI Python client (`pip install openai`)
- SQLite (included in Python standard library)
- xAI API key (obtain from [xAI](https://x.ai/api))

## Project Structure

The application consists of a single Python script that handles:
- Database setup with SQLite
- Conversation management
- API integration with xAI's Grok
- Streamlit UI for chat and conversation navigation

Below is the complete code, followed by a detailed breakdown.

```python
import streamlit as st
from openai import OpenAI
import sqlite3
import uuid
from datetime import datetime

# Database setup
def init_db():
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    c.execute('''
    CREATE TABLE IF NOT EXISTS conversations
    (conversation_id TEXT, timestamp TEXT)
    ''')
    c.execute('''
    CREATE TABLE IF NOT EXISTS messages
    (id INTEGER PRIMARY KEY, conversation_id TEXT, role TEXT, content TEXT, timestamp TEXT)
    ''')
    conn.commit()
    conn.close()

def save_message(conversation_id, role, content):
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    timestamp = datetime.now().isoformat()
    c.execute("INSERT INTO messages (conversation_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
              (conversation_id, role, content, timestamp))
    conn.commit()
    conn.close()

def get_conversation_history(conversation_id):
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    c.execute("SELECT role, content FROM messages WHERE conversation_id = ? ORDER BY id", (conversation_id,))
    messages = c.fetchall()
    conn.close()
    return [{"role": role, "content": content} for role, content in messages]

def get_all_conversations():
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    c.execute("SELECT DISTINCT conversation_id, timestamp FROM conversations ORDER BY timestamp DESC")
    conversations = c.fetchall()
    conn.close()
    return conversations

def create_new_conversation():
    conversation_id = str(uuid.uuid4())
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    timestamp = datetime.now().isoformat()
    c.execute("INSERT INTO conversations (conversation_id, timestamp) VALUES (?, ?)", 
              (conversation_id, timestamp))
    conn.commit()
    conn.close()
    
    # Add system message to the new conversation
    system_message = "You are Grok, an extremely intelligent developer and entrepreneur. Specializing in various programming languages."
    save_message(conversation_id, "system", system_message)
    
    return conversation_id

# Initialize database
init_db()

# Initialize xAI client with hardcoded API key
client = OpenAI(
    api_key="you're_api_key_here",  
    base_url="https://api.x.ai/v1"
)

# Initialize session state
if "conversation_id" not in st.session_state:
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    c.execute("SELECT conversation_id FROM conversations ORDER BY timestamp DESC LIMIT 1")
    result = c.fetchone()
    conn.close()
    
    if result:
        st.session_state.conversation_id = result[0]
    else:
        st.session_state.conversation_id = create_new_conversation()

# Sidebar for conversation management
with st.sidebar:
    st.title("Conversations")
    
    if st.button("New Conversation"):
        st.session_state.conversation_id = create_new_conversation()
        st.rerun()
    
    st.subheader("Previous Conversations")
    conversations = get_all_conversations()
    
    for conv_id, timestamp in conversations:
        dt = datetime.fromisoformat(timestamp)
        formatted_time = dt.strftime("%Y-%m-%d %H:%M")
        if st.button(f"{formatted_time}", key=conv_id):
            st.session_state.conversation_id = conv_id
            st.rerun()

# Main chat interface
st.title("Chat with GrokMonster")

# Load conversation history
conversation_history = []
if st.session_state.conversation_id:
    conversation_history = get_conversation_history(st.session_state.conversation_id)

# Input box for user message
user_input = st.text_input("Your message:", key="user_input")

if st.button("Send"):
    if user_input and st.session_state.conversation_id:
        save_message(st.session_state.conversation_id, "user", user_input)
        try:
            messages = get_conversation_history(st.session_state.conversation_id)
            response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                max_tokens=2000,
                temperature=0.7
            )
            grok_response = response.choices[0].message.content
            save_message(st.session_state.conversation_id, "assistant", grok_response)
        except Exception as e:
            st.error(f"Error: {str(e)}")
        st.rerun()

# Display conversation
for msg in conversation_history:
    if msg["role"] == "user":
        st.write(f"**You**: {msg['content']}")
    elif msg["role"] == "assistant":
        st.write(f"**Grok**: {msg['content']}")
```

## Step-by-Step Breakdown

### 1. Setting Up the Database

The app uses SQLite to store conversations and messages. The `init_db` function creates two tables:

- **conversations**: Stores unique conversation IDs and timestamps.
- **messages**: Stores individual messages with their conversation ID, role (user, assistant, or system), content, and timestamp.

```python
def init_db():
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    c.execute('''
    CREATE TABLE IF NOT EXISTS conversations
    (conversation_id TEXT, timestamp TEXT)
    ''')
    c.execute('''
    CREATE TABLE IF NOT EXISTS messages
    (id INTEGER PRIMARY KEY, conversation_id TEXT, role TEXT, content TEXT, timestamp TEXT)
    ''')
    conn.commit()
    conn.close()
```

The database is initialized when the app starts with `init_db()`.

### 2. Database Operations

Several functions manage data storage and retrieval:

- **save_message**: Saves a message to the `messages` table with the conversation ID, role, content, and timestamp.
- **get_conversation_history**: Retrieves all messages for a given conversation ID, formatted as a list of role-content dictionaries.
- **get_all_conversations**: Fetches all conversation IDs and their timestamps, ordered by recency.
- **create_new_conversation**: Generates a unique conversation ID, saves it to the `conversations` table, and adds a system message defining Grok's role.

```python
def create_new_conversation():
    conversation_id = str(uuid.uuid4())
    conn = sqlite3.connect('chat_history.db')
    c = conn.cursor()
    timestamp = datetime.now().isoformat()
    c.execute("INSERT INTO conversations (conversation_id, timestamp) VALUES (?, ?)", 
              (conversation_id, timestamp))
    conn.commit()
    conn.close()
    
    # Add system message to the new conversation
    system_message = "You are Grok, an extremely intelligent developer and entrepreneur. Specializing in various programming languages."
    save_message(conversation_id, "system", system_message)
    
    return conversation_id
```

### 3. xAI API Integration

The app uses the OpenAI client to connect to xAI's API:

```python
client = OpenAI(
    api_key="you're_api_key_here",  
    base_url="https://api.x.ai/v1"
)
```

When a user sends a message, the app:
1. Saves the user's message to the database
2. Retrieves the full conversation history
3. Sends the history to xAI's API
4. Saves Grok's response to the database

```python
if st.button("Send"):
    if user_input and st.session_state.conversation_id:
        save_message(st.session_state.conversation_id, "user", user_input)
        try:
            messages = get_conversation_history(st.session_state.conversation_id)
            response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                max_tokens=2000,
                temperature=0.7
            )
            grok_response = response.choices[0].message.content
            save_message(st.session_state.conversation_id, "assistant", grok_response)
        except Exception as e:
            st.error(f"Error: {str(e)}")
        st.rerun()
```

### 4. Streamlit UI

The UI is built with Streamlit and consists of:

- A sidebar for managing conversations
- A main chat interface for displaying messages
- An input box for sending new messages

```python
# Sidebar for conversation management
with st.sidebar:
    st.title("Conversations")
    
    if st.button("New Conversation"):
        st.session_state.conversation_id = create_new_conversation()
        st.rerun()
    
    st.subheader("Previous Conversations")
    conversations = get_all_conversations()
    
    for conv_id, timestamp in conversations:
        dt = datetime.fromisoformat(timestamp)
        formatted_time = dt.strftime("%Y-%m-%d %H:%M")
        if st.button(f"{formatted_time}", key=conv_id):
            st.session_state.conversation_id = conv_id
            st.rerun()
```

The chat display shows messages with different formatting based on their role:

```python
# Display conversation
for msg in conversation_history:
    if msg["role"] == "user":
        st.write(f"**You**: {msg['content']}")
    elif msg["role"] == "assistant":
        st.write(f"**Grok**: {msg['content']}")
```

## Running the Application

To run this application:

1. Save the code in a file (e.g., `app.py`).
2. Install dependencies: `pip install streamlit openai`.
3. Replace the API key placeholder with your actual xAI API key.
4. Run the app: `streamlit run app.py`.

The app will launch in your browser, allowing you to chat with Grok and manage conversations.

## Conclusion

This tutorial demonstrated how to build a chat application with Streamlit and xAI's Grok API. The app provides a simple yet effective interface for interacting with Grok, with the added benefit of conversation persistence through SQLite.

You can extend this application by:
- Adding user authentication
- Implementing conversation titles
- Adding the ability to delete conversations
- Enhancing the UI with custom CSS
- Implementing streaming responses for a more interactive experience

Happy coding!

Learn how to create a chat application using Streamlit, SQLite for conversation storage, and xAI's Grok API for AI responses.

Building a Chat Application with Streamlit, SQLite, and xAI's Grok API

<img
_src_="/images/ai_openwebui_litellm.jpg"
_alt_="Open WebUI with LiteLLM Self-Hosted AI Server"
_className_="header-image"
_style_={{
width: '100%',
maxHeight: '400px',
objectFit: 'cover',
marginBottom: '2rem'
}}
/>

# AI with Open WebUI + LiteLLM: Self-Hosted AI Solution

Run OpenWebUI on your own VPS with Hostinger and create a powerful self-hosted AI environment. This setup allows you to use multiple AI models simultaneously, creating a one-to-many scenario where you can compare responses across different models. For example, you could ask what your country would have been like if some historical event didn't happen, and get multiple AI perspectives at once.

One significant advantage of this approach is cost efficiency. Purchasing API tokens can sometimes be more economical than paying standard monthly subscription fees, depending on your usage patterns.

## How to Access Multiple AI Models from One Self-Hosted Interface

### Step 1: Choose Your Hosting Method

- **Cloud Option**: Set up a VPS (Virtual Private Server) on a hosting provider
 - Recommended: KVM2 plan with 8GB RAM and NVMe storage
 - Consider a 12-month term for better pricing

- **On-Premises Option**: Host on your own hardware (laptop, NAS, Raspberry Pi)

### Step 2: Set Up the Server with OpenWebUI

1. If using a cloud provider like Hostinger.com:
 - Select "Applications" during setup
 - Choose Llama as application (includes OpenWebUI)
 - Set a secure root password
 - Wait for server deployment (usually a few minutes)

2. Once deployed:
 - Access the server management page
 - Click "Manage" then "Manage App"
 - This opens OpenWebUI running on port 8080

### Step 3: Create Your Admin Account

1. Click "Get Started" on the OpenWebUI welcome page
2. Create your admin account with full privileges

### Step 4: Connect to AI Providers via API Keys

1. **For OpenAI (ChatGPT)**:
 - Go to openai.com/api and sign up/sign in
 - Add a payment method (you'll only be charged for what you use)
 - Add $5 credit to start
 - Go to Settings → API Keys → Create new secret key
 - Copy the API key
 - In OpenWebUI, go to Profile → Admin Panel → Settings → Connections
 - Paste your OpenAI API key and save

2. **For more AI providers (Claude, Gemini, Grok, etc.)**:
 - Install LiteLLM as a proxy server
 - SSH into your server or use the browser terminal
 - Run: `git clone https://github.com/BerriAI/litellm.git`
 - Navigate to the folder: `cd litellm`
 - Create an env file: `nano .env`
 - Add two configuration lines:
 ```
 LITELLM_MASTER_KEY="sk-randomcharacters"
 LITELLM_SALT_KEY="sk-randomcharacters"
 ```
 - Save the file (Ctrl+X, Y, Enter)
 - Run: `docker-compose up -d`
 - Access LiteLLM interface at your-ip-address:4000
 - Log in with username "admin" and the master key you created

### Step 5: Add Models to LiteLLM

1. In LiteLLM admin panel, go to "Models"
2. Click "Add Model"
3. Select provider (Anthropic, Google, OpenAI, etc.)
4. Choose specific models you want to use
5. Enter your API key for that provider
6. Click "Add Model"

### Step 6: Create Virtual API Keys

1. In LiteLLM, go to "Virtual Keys"
2. Create a new key
3. Name it (e.g., "kids", "employees")
4. Select which models this key can access
5. Set a monthly budget limit if desired
6. Copy the generated key

### Step 7: Connect OpenWebUI to LiteLLM

1. In OpenWebUI, go to Admin Panel → Settings → Connections
2. Add your LiteLLM virtual API key under OpenAI API
3. Set the base URL to: `http://localhost:4000` (if hosted on same server)
4. Click "Verify Connection" then "Save"

### Step 8: Create User Accounts & Set Permissions

1. In OpenWebUI, go to Admin Panel → Settings → Users
2. Create groups (e.g., "kids", "employees")
3. Create user accounts and assign them to groups
4. Set permissions for each group:
 - Which models they can access
 - Whether they can use tools/plugins
 - Access to knowledge bases
5. Add system prompts to models for safety (e.g., prevent homework cheating)

## Monitor Usage and Set Budgets

- Check the LiteLLM "Usage" tab to monitor spending
- Set budget limits on virtual API keys to prevent overspending
- Review conversation logs through the OpenWebUI admin panel

## Important Considerations

- Be aware of token pricing (pay-per-use model)
- Different models have different pricing (GPT-4.5 is much more expensive than GPT-3.5)
- Long conversations use more tokens as context is maintained
- Monitor usage to avoid unexpected costs

A comprehensive guide to setting up your own AI server with Open WebUI and LiteLLM, allowing you to access multiple AI models from a single self-hosted interface.

AI with Open WebUI + LiteLLM: Self-Hosted AI Solution


# Scripting Playground

Automation is at the core of modern network operations, and Python provides powerful capabilities for streamlining network management. Below are some of the practical scripts I work with to enhance network efficiency, monitor device health, and automate configuration tasks.

## Cisco Network Health Checks

### 1. Cisco Switch Health Check
Perform a quick health assessment of a Cisco switch, including CPU utilization, memory usage, and interface errors.

```python
from netmiko import ConnectHandler

switch = {
    "device_type": "cisco_ios",
    "host": "192.168.1.1",
    "username": "admin",
    "password": "password",
}

conn = ConnectHandler(**switch)
output = conn.send_command("show processes cpu | include CPU utilization")
print("CPU Utilization:", output)
conn.disconnect()
```

### 2. Cisco WLC Health Check
Retrieve the number of active APs, client associations, and system uptime from a Cisco Wireless LAN Controller.

```python
from netmiko import ConnectHandler

wlc = {
    "device_type": "cisco_wlc",
    "host": "192.168.1.2",
    "username": "admin",
    "password": "password",
}

conn = ConnectHandler(**wlc)
output = conn.send_command("show ap summary")
print(output)
conn.disconnect()
```

### 3. Cisco ISE Health Check
Check the status of key services running on Cisco ISE.

```python
from netmiko import ConnectHandler

ise = {
    "device_type": "cisco_ios",
    "host": "192.168.1.3",
    "username": "admin",
    "password": "password",
}

conn = ConnectHandler(**ise)
output = conn.send_command("show application status ise")
print(output)
conn.disconnect()
```

## Network Data Collection

### 4. Collect MAC Address Table
Gather MAC address table details from a switch.

```python
output = conn.send_command("show mac address-table")
print(output)
```

### 5. Interface Status & Descriptions
Retrieve interface descriptions and statuses to monitor connectivity.

```python
output = conn.send_command("show interfaces description")
print(output)
```

### 6. Check Cisco AP Link Speed
Verify if a Cisco AP is connected at an optimal interface speed.

```python
output = conn.send_command("show interface GigabitEthernet1/0/1 | include input rate")
print("AP Interface Speed:", output)
```

## Network Security & Optimization

### 7. Remove Outdated Security Vulnerabilities
Identify weak security settings such as outdated ciphers or Telnet usage.

```python
commands = [
    "show running-config | include enable secret",
    "show running-config | include telnet"
]

for cmd in commands:
    print(conn.send_command(cmd))
```

### 8. Generate Jinja2 Configurations
Use Jinja2 templating to create consistent switch configurations.

```python
from jinja2 import Template

template = Template("""
hostname {{ hostname }}
interface GigabitEthernet1/0/1
 description Uplink
 switchport mode trunk
""")

config = template.render(hostname="SW1")
print(config)
```

## Bulk Deployment & Configuration

### 9. Deploy Minimal Configurations on Multiple Switches
Push SNMP configurations to hundreds of devices.

```python
commands = [
    "snmp-server community public RO",
    "snmp-server community private RW"
]

for cmd in commands:
    print(conn.send_config_set(cmd))
```

### 10. Deploy Large-Scale Network Configurations with Ansible
Automate major configuration changes across the network.

```yaml
- name: Configure EIGRP on Cisco Switches
  hosts: switches
  gather_facts: no
  tasks:
    - name: Configure EIGRP
      ios_config:
        lines:
          - router eigrp 100
          - network 10.1.1.0 0.0.0.255
        save_when: changed
```

## Network Mapping & Analysis

### 11. Map Network Using CDP Neighbors
Identify neighboring devices and map network topology.

```python
output = conn.send_command("show cdp neighbors detail")
print(output)
```

### 12. Collect Fiber Cable Alerts & Errors
Check fiber link quality and identify alarm conditions.

```python
output = conn.send_command("show interfaces transceiver detail")
print(output)
```

## VLAN & Logging Automation

### 13. Fetch VLAN Database Information
Retrieve and analyze VLAN configurations from a switch.

```python
output = conn.send_command("show vlan brief")
print(output)
```

### 14. Deploy Log Filters in Bulk
Automate syslog filter configuration across multiple devices.

```python
commands = [
    "logging buffered 100000",
    "logging trap informational"
]

for cmd in commands:
    print(conn.send_config_set(cmd))
```

## Conclusion
The scripts above showcase how Python can be leveraged for network automation, data collection, security enforcement, and large-scale deployments. By continuously refining these scripts, I aim to enhance efficiency and reliability in network operations.

If you're interested in collaborating or learning more, feel free to reach out!


Exploring practical Python scripts for network automation

Scripting Playground


# CI/CD for Network Automation

Continuous Integration and Continuous Deployment (CI/CD) is transforming network automation by enabling seamless, version-controlled deployments. By integrating **Git**, **Jenkins**, and **Ansible**, network engineers can automate configurations, enforce compliance, and reduce human errors.

## Why CI/CD for Network Automation?

Traditional network operations often involve manual configuration, leading to inconsistency and deployment delays. CI/CD pipelines help:
- Automate network changes.
- Ensure version control for configurations.
- Validate configurations before deployment.
- Reduce downtime and human error.
- Enable **Infrastructure as Code (IaC)** for networking.

## Key Tools for CI/CD in Networking

### 1. **Git** – Version Control for Network Configurations
Git helps track changes in network configurations, ensuring that updates are documented and reversible.

### 2. **Jenkins** – CI/CD Orchestration
Jenkins automates the process of testing and deploying configurations to network devices.

### 3. **Ansible** – Automated Deployment
Ansible ensures seamless and consistent application of network configurations across multiple devices.

## CI/CD Pipeline Overview

A typical CI/CD pipeline for network automation follows these steps:

1. **Developer pushes a network config change to Git.**
2. **Jenkins detects the change and triggers a build.**
3. **Jenkins runs Ansible playbooks to validate and test the config.**
4. **If successful, Jenkins deploys the configuration to production.**

## Step-by-Step Implementation

### 1. Setting Up Git for Network Configuration Management

Initialize a Git repository for network configurations:
```bash
git init network-configs
cd network-configs
git add .
git commit -m "Initial commit of network configurations"
git push origin main
```

### 2. Writing an Ansible Playbook for Configuration Deployment

Create an Ansible playbook (`deploy_config.yml`) to apply configurations.

```yaml
- name: Deploy network configurations
  hosts: switches
  gather_facts: no
  tasks:
    - name: Apply configuration
      ios_config:
        src: templates/switch_config.j2
      register: output

    - name: Show results
      debug:
        var: output
```

### 3. Configuring Jenkins for Automated Deployment

#### Install Required Plugins:
- **Git Plugin** (for pulling configurations from Git)
- **Ansible Plugin** (for executing Ansible playbooks)

#### Create a New Jenkins Job:
1. **Source Code Management:** Connect Jenkins to your Git repository.
2. **Build Steps:** Add the following command to execute the Ansible playbook:
   ```bash
   ansible-playbook -i inventory deploy_config.yml
   ```
3. **Post-Build Actions:** Notify the team via email or Slack if deployment succeeds or fails.

### 4. Automating the Pipeline

To make the pipeline fully automated, configure **Git Webhooks** to trigger Jenkins whenever a new commit is pushed.

#### Example Webhook for GitHub:
1. Go to **GitHub → Repository Settings → Webhooks**.
2. Add a new webhook pointing to Jenkins:
   ```bash
   http://jenkins.example.com/github-webhook/
   ```
3. Select "Push Events" to trigger Jenkins when a new commit is made.

## Testing & Validation

Before deploying configurations, validate syntax and functionality using Ansible.
```bash
ansible-playbook --syntax-check deploy_config.yml
```

Additionally, use **Jenkins stages** to run dry-run tests before applying configurations to production devices.

## Rollback Mechanism

If an error occurs, rollback to the previous configuration using Git:
```bash
git revert HEAD
```
Or, use Ansible to restore a backup config:
```yaml
- name: Rollback to last stable configuration
  hosts: switches
  gather_facts: no
  tasks:
    - name: Restore backup config
      ios_config:
        src: backups/last_working_config.j2
```

## Conclusion

Integrating **Git, Jenkins, and Ansible** into a CI/CD pipeline enables efficient, error-free, and automated network deployments. By following these steps, you can:
- Improve network configuration consistency.
- Reduce manual intervention.
- Ensure quick rollbacks when needed.

This approach aligns networking with modern **DevOps** practices, making it more scalable and manageable. 🚀


Integrating Git, Jenkins, and Ansible for automated network deployments

CI/CD for Network Automation


# Cisco APIs

Cisco provides powerful APIs for automating and managing network infrastructures. This page explores how to interact with **Cisco Catalyst Center, DNA Center (DNAC), Meraki, and ISE APIs** using Python.

## Why Use Cisco APIs?

- **Automation**: Reduce manual tasks and improve efficiency.
- **Monitoring & Insights**: Retrieve real-time network data.
- **Configuration Management**: Modify and deploy network settings programmatically.
- **Security & Compliance**: Ensure policies are enforced across devices.

---

## 1. Getting Started with Cisco APIs

Before diving into code, ensure you have the required dependencies:
```bash
pip install requests dnacentersdk meraki
```

Most Cisco APIs require authentication. Here’s an example of how to authenticate with Cisco DNA Center:

```python
import requests

DNAC_URL = "https://sandboxdnac2.cisco.com"
USERNAME = "devnetuser"
PASSWORD = "Cisco123!"

# Authenticate and get a token
def get_dnac_token():
    url = f"{DNAC_URL}/dna/system/api/v1/auth/token"
    response = requests.post(url, auth=(USERNAME, PASSWORD), verify=False)
    return response.json()["Token"]

token = get_dnac_token()
print("Token:", token)
```

---

## 2. Cisco Catalyst Center API - Retrieve Network Devices

```python
headers = {"X-Auth-Token": token, "Content-Type": "application/json"}
url = f"{DNAC_URL}/dna/intent/api/v1/network-device"
response = requests.get(url, headers=headers, verify=False)

for device in response.json()["response"]:
    print(f"Device: {device['hostname']} - Type: {device['type']}")
```

---

## 3. Meraki API - Get Organization Networks

```python
from meraki import DashboardAPI

API_KEY = "your_meraki_api_key"
dashboard = DashboardAPI(API_KEY)

orgs = dashboard.organizations.getOrganizations()
org_id = orgs[0]["id"]
networks = dashboard.organizations.getOrganizationNetworks(org_id)

for net in networks:
    print(f"Network Name: {net['name']} - ID: {net['id']}")
```

---

## 4. Cisco ISE API - Get Endpoint Details

```python
ISE_URL = "https://your-ise-server:9060"
ISE_USERNAME = "admin"
ISE_PASSWORD = "yourpassword"

def get_ise_endpoints():
    url = f"{ISE_URL}/ers/config/endpoint"
    headers = {"Accept": "application/json"}
    response = requests.get(url, auth=(ISE_USERNAME, ISE_PASSWORD), headers=headers, verify=False)
    return response.json()

endpoints = get_ise_endpoints()
print(endpoints)
```

---

## 5. Useful Cisco API Resources

### Documentation:
- [Cisco DevNet API Reference](https://developer.cisco.com/)
- [Cisco DNA Center API](https://developer.cisco.com/docs/dna-center/)
- [Cisco Meraki API Docs](https://developer.cisco.com/meraki/)
- [Cisco ISE API Guide](https://developer.cisco.com/docs/identity-services-engine/)

### Video Tutorials:
- [Automating Cisco DNA Center with Python](https://www.youtube.com/watch?v=yp-LRzWn0Hk)
- [Introduction to Cisco Meraki API](https://www.youtube.com/watch?v=7t4mUrMdakU)
- [Using Cisco ISE APIs](https://www.youtube.com/watch?v=YKrMUSoygDA)

---

## Conclusion

By leveraging **Cisco APIs**, you can automate configurations, retrieve critical data, and enhance network management. Explore the above scripts and integrate them into your workflows!

 **Start automating your Cisco network today!**


Tutorials on interacting with Cisco Catalyst Center, DNAC, Meraki, and ISE APIs

Cisco APIs


# REST API vs. gRPC for Network Engineers

Modern network automation requires efficient communication between systems, often relying on APIs. **REST API** and **gRPC** are two leading approaches, but they serve different purposes. This article explores their strengths, weaknesses, and when network engineers should use each.

---

## What is REST API?

**REST (Representational State Transfer)** is an architectural style for web services that leverages HTTP methods like GET, POST, PUT, and DELETE. REST APIs typically use JSON or XML as data formats.

### **Key Features of REST API:**
✔ **Human-readable (JSON/XML)**: Easy to debug and integrate with web applications.
✔ **Stateless Communication**: Each request is independent, reducing complexity.
✔ **Widely Adopted**: Supported across various platforms and tools.
✔ **Simple and Scalable**: Best for public-facing APIs and general automation tasks.

### **Example: Retrieving Network Device Information via REST API (Cisco DNA Center)**

```python
import requests

DNAC_URL = "https://sandboxdnac.cisco.com"
USERNAME = "devnetuser"
PASSWORD = "Cisco123!"

# Authenticate and retrieve a token
def get_dnac_token():
    url = f"{DNAC_URL}/dna/system/api/v1/auth/token"
    response = requests.post(url, auth=(USERNAME, PASSWORD), verify=False)
    return response.json()["Token"]

token = get_dnac_token()
headers = {"X-Auth-Token": token, "Content-Type": "application/json"}

# Fetch network device details
def get_network_devices():
    url = f"{DNAC_URL}/dna/intent/api/v1/network-device"
    response = requests.get(url, headers=headers, verify=False)
    return response.json()

devices = get_network_devices()
print(devices)
```

---

## What is gRPC?

**gRPC (Google Remote Procedure Call)** is a high-performance, open-source framework for remote procedure calls. It uses **Protocol Buffers (Protobufs)** instead of JSON, making it faster and more efficient.

### **Key Features of gRPC:**
✔ **Binary Data Format (Protobuf)**: More efficient than JSON.
✔ **Bidirectional Streaming**: Supports real-time communication.
✔ **Strongly Typed Contracts**: Ensures strict schema enforcement.
✔ **High Performance**: Faster than REST due to binary serialization.
✔ **Ideal for Large-Scale Automation**: Suitable for high-speed network configurations.

### **Example: Retrieving Network Device Information via gRPC (Cisco gNMI)**

1. **Define the Protobuf schema (device.proto)**:
```protobuf
syntax = "proto3";
package network;

service NetworkService {
  rpc GetDevices (DeviceRequest) returns (DeviceList);
}

message DeviceRequest {}

message Device {
  string hostname = 1;
  string ip_address = 2;
  string status = 3;
}

message DeviceList {
  repeated Device devices = 1;
}
```

2. **Generate the gRPC client and server from Protobuf:**
```bash
python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. device.proto
```

3. **Implement the gRPC Client in Python:**
```python
import grpc
import device_pb2
import device_pb2_grpc

# Establish a connection
channel = grpc.insecure_channel('localhost:50051')
client = device_pb2_grpc.NetworkServiceStub(channel)

# Fetch network devices
device_request = device_pb2.DeviceRequest()
devices = client.GetDevices(device_request)

for device in devices.devices:
    print(f"Device: {device.hostname} - IP: {device.ip_address} - Status: {device.status}")
```

---

## REST vs. gRPC: When to Use Each

| Feature          | REST API | gRPC |
|-----------------|----------|------|
| **Data Format**  | JSON/XML (text-based) | Protobuf (binary) |
| **Performance**  | Slower (human-readable) | Faster (efficient serialization) |
| **Streaming**    | No native support | Supports bidirectional streaming |
| **Error Handling** | Simple HTTP codes | More granular status messages |
| **Adoption**     | Universal (browsers, CLI, etc.) | Requires gRPC-compatible clients |
| **Security**     | Standard HTTPS & OAuth | TLS encryption built-in |

### **When to Use REST API?**
✅ When human readability is essential (e.g., web-based automation).
✅ When integrating with existing tools that rely on JSON.
✅ When working with RESTful APIs such as **Cisco DNA Center, Meraki, or ISE**.

### **When to Use gRPC?**
✅ When high-performance communication is required.
✅ When dealing with large-scale automation (e.g., SD-WAN, Telemetry).
✅ When real-time streaming is needed (e.g., **gNMI for Cisco devices**).

---

## Additional Resources

### **Cisco API and gRPC Learning Materials:**
- [Cisco DevNet - REST APIs](https://developer.cisco.com/)
- [Cisco gNMI (gRPC Network Management Interface)](https://developer.cisco.com/docs/gnmi/)
- [REST vs. gRPC Explained (YouTube)](https://www.youtube.com/watch?v=QYzE73XpiiM)
- [Cisco Telemetry using gRPC (YouTube)](https://www.youtube.com/watch?v=sgf2OvXNW3A)

---

## Conclusion

Both **REST API** and **gRPC** serve unique roles in network automation. REST is ideal for standard automation tasks, while gRPC excels in high-performance, large-scale deployments. Network engineers should choose based on use case, performance needs, and existing infrastructure.

 **Ready to implement network automation? Start experimenting with both REST and gRPC today!**

A breakdown of when to use REST or gRPC for network automation and management.

REST API vs. gRPC for Network Engineers


# Cisco Catalyst Center and Its Role in Automation

Cisco Catalyst Center (formerly Cisco DNA Center) is a powerful network management and automation platform designed to simplify and enhance enterprise networking. It provides a centralized interface for managing wired and wireless networks, offering automation, analytics, and security features that improve network efficiency and reliability. With its intent-based networking capabilities, Catalyst Center enables organizations to automate configurations, enforce policies, and monitor network health in real-time, reducing the need for manual intervention.

## API-Driven Network Management

One of Catalyst Center's key strengths is its deep integration with automation frameworks and APIs, making it a critical tool for network engineers and DevOps teams. Through its **RESTful APIs**, engineers can programmatically interact with the platform, automate routine tasks, and retrieve network insights for data-driven decision-making. For example, automation scripts written in Python can leverage Catalyst Center's APIs to configure VLANs, provision new devices, and analyze telemetry data across the network. This automation capability not only enhances efficiency but also ensures network consistency and reduces human errors.

## Cisco DevNet and Catalyst Center Integration

Cisco **DevNet**, Cisco's developer community and automation ecosystem, plays a vital role in maximizing the capabilities of Catalyst Center. DevNet provides extensive documentation, code samples, sandboxes, and learning labs that help engineers and developers leverage Catalyst Center's programmability features. Through DevNet, engineers can learn how to use **Python, Ansible, and Terraform** to automate deployments, implement network security policies, and perform advanced analytics on network data collected from Catalyst Center.

## Embracing NetDevOps

Catalyst Center's integration with DevNet encourages a **NetDevOps approach**, where traditional network engineering merges with software development principles. Engineers can use **Infrastructure as Code (IaC)** techniques to define network policies and automate deployments through version-controlled scripts. This approach enhances agility, allowing networks to be provisioned dynamically in response to business needs. Moreover, the **Model-Driven Telemetry** capabilities in Catalyst Center provide real-time data streams that can be processed using DevNet tools, enabling proactive monitoring and troubleshooting.

## The Future of Network Automation

With enterprises increasingly adopting software-defined networking (SDN) and cloud-based infrastructure, Cisco Catalyst Center, combined with DevNet resources, empowers engineers to create intelligent, self-healing networks. By automating configurations, continuously monitoring network health, and integrating with third-party automation tools, Catalyst Center helps organizations achieve a **scalable, secure, and efficient** networking environment. As businesses continue to embrace **AI-driven operations and predictive analytics**, Catalyst Center is poised to play a crucial role in the future of **autonomous networking**.

```python
# Example: Using Python to retrieve network devices from Catalyst Center
import requests
import json
from requests.auth import HTTPBasicAuth
import urllib3

# Disable SSL warnings (for lab environments only)
urllib3.disable_warnings()

# Catalyst Center details
CATALYST_CENTER_URL = "https://10.10.10.10"
USERNAME = "admin"
PASSWORD = "password"

# Get authentication token
def get_auth_token():
    url = f"{CATALYST_CENTER_URL}/dna/system/api/v1/auth/token"
    response = requests.post(
        url,
        auth=HTTPBasicAuth(USERNAME, PASSWORD),
        verify=False
    )
    token = response.json()["Token"]
    return token

# Get all network devices
def get_network_devices(token):
    url = f"{CATALYST_CENTER_URL}/dna/intent/api/v1/network-device"
    headers = {
        "Content-Type": "application/json",
        "X-Auth-Token": token
    }
    response = requests.get(url, headers=headers, verify=False)
    return response.json()

# Main execution
try:
    # Get token
    token = get_auth_token()
    print("Successfully authenticated to Catalyst Center")
    
    # Get and display network devices
    devices = get_network_devices(token)
    print(f"Found {len(devices['response'])} network devices")
    
    # Display device details
    for device in devices['response']:
        print(f"\nDevice: {device['hostname']}")
        print(f"  Type: {device['type']}")
        print(f"  IP: {device['managementIpAddress']}")
        print(f"  Software: {device['softwareVersion']}")
        print(f"  Platform: {device['platformId']}")
        print(f"  Uptime: {device['upTime']}")
        
except Exception as e:
    print(f"Error: {str(e)}")
```

How Cisco Catalyst Center and DevNet integration enable powerful network automation capabilities for modern enterprise networks.

Cisco Catalyst Center and Its Role in Automation

<img 
 src="/images/python_cisco.jpg" 
 alt="Cisco and Python Network Automation" 
 className="header-image"
 style={{
 width: '100%',
 maxHeight: '400px',
 objectFit: 'cover',
 marginBottom: '2rem'
 }}
/>

# Cisco and Python: Powering Network Automation

Cisco and Python are a powerful combination for modern network automation, programmability, and orchestration. Cisco, a leading provider of networking hardware and software, has embraced automation as a key component of its solutions, offering APIs and software development kits (SDKs) to facilitate efficient management of networks. Python, a widely used and versatile programming language, has become the preferred choice for network engineers due to its simplicity, extensive libraries, and strong community support. By integrating Python with Cisco technologies, IT professionals can automate network configurations, optimize performance, and improve operational efficiency.

One of the biggest advantages of using Python with Cisco devices is the ability to automate repetitive tasks. Traditional network management often requires manually configuring devices through command-line interfaces (CLI), which can be time-consuming and error-prone. Python allows engineers to write scripts that automate configurations across multiple devices, reducing human error and improving consistency. Cisco's support for automation tools such as Netmiko, Paramiko, and NAPALM further enhances this capability, making it easier to manage routers, switches, and firewalls programmatically.

Another key benefit is the ability to leverage Cisco's APIs, such as those available in Cisco DNA Center, Cisco Catalyst Center, and Cisco Meraki. These APIs enable network engineers to programmatically interact with network infrastructure, collect real-time telemetry data, and implement policy-based automation. For instance, Python scripts can be used to monitor network health, detect anomalies, and trigger automated responses to issues, improving overall network reliability and security. Additionally, Python's integration with data analytics tools and machine learning frameworks allows organizations to gain deeper insights from network data, enabling proactive decision-making.

Furthermore, Python's compatibility with Cisco's model-driven programmability using YANG data models and protocols like NETCONF and RESTCONF enables dynamic, scalable, and intent-based networking. Engineers can create network configurations using structured data formats such as JSON or XML, apply them across the infrastructure, and maintain version control for easier troubleshooting and rollbacks. This approach aligns with the growing trend of Software-Defined Networking (SDN), where Python plays a crucial role in managing network functions programmatically.

In summary, the combination of Cisco and Python provides a flexible, scalable, and efficient approach to network automation and management. By leveraging Python's scripting capabilities with Cisco's extensive API ecosystem, organizations can streamline operations, reduce manual workload, enhance security, and ensure a more agile and resilient network infrastructure.

Exploring how Python and Cisco technologies combine to enable powerful network automation, programmability, and orchestration solutions.

Cisco and Python: Powering Network Automation


# DevNet Resources: Where Networking Meets Code

Welcome to your guide for bridging the gap between traditional networking and modern development practices.

## Getting Started with DevNet

DevNet is Cisco's developer program designed to help network engineers embrace programming skills. Here's how to begin your journey:

1. Create a free DevNet account at [developer.cisco.com](https://developer.cisco.com)
2. Explore the learning tracks based on your interests
3. Join the DevNet community forums to connect with peers

## DevNet Certification Paths

Validate your network programming skills with these certifications:

- DevNet Associate
- DevNet Professional 
- DevNet Expert

Each level builds upon fundamental programming concepts while applying them to network automation scenarios.

---

Resources for network engineers looking to enhance their skills with programming, automation, and Cisco DevNet capabilities.

A step-by-step guide for network engineers new to programming

Getting Started with DevNet

Overview of Cisco's developer certifications

DevNet Certification Paths

Information about how to access Cisco's free lab environments

DevNet Sandbox

Basic Python concepts, automation libraries, and code samples

Python for Network Engineers

Overview of REST, NETCONF, platforms like DNA Center, and documentation

Cisco APIs and Platforms

Automation examples, monitoring tools, and infrastructure as code

Use Cases & Tutorials

Connect with other network developers and find learning resources

Community Resources

DevNet Resources: Where Networking Meets Code

<img 
 src="/images/python_cisco.jpg" 
 alt="Python Libraries for Network Engineers" 
 className="header-image"
 style={{
 width: '100%',
 maxHeight: '400px',
 objectFit: 'cover',
 marginBottom: '2rem'
 }}
/>

# Python Libraries for Network Engineers

Python has become the go-to language for network engineers due to its ease of use and vast ecosystem of libraries designed for network automation, device management, and data analysis. Several Python libraries stand out as essential tools for network engineers, enabling them to automate tasks, interact with network devices, and analyze network data efficiently.

## Connection Management & Device Interaction

One of the most widely used libraries is **Netmiko**, developed by Kirk Byers. Netmiko simplifies SSH connections to network devices and provides an easy way to send commands and retrieve output. It abstracts many complexities of interacting with Cisco, Juniper, Arista, and other vendor devices, making it a preferred choice for automating configuration changes and collecting device data. Another essential library is **Paramiko**, which provides low-level SSH functionality and is useful when custom SSH interactions are needed beyond what Netmiko offers.

## Multi-vendor Automation

For network automation and API-based interactions, **NAPALM (Network Automation and Programmability Abstraction Layer with Multivendor support)** is a powerful library. It allows engineers to retrieve operational data, manage configurations, and ensure consistency across multiple network vendors using a single API. Similarly, **pyATS (Python Automated Test System)**, developed by Cisco, is widely used for network testing, validation, and verification, helping engineers ensure the reliability of their configurations and deployments.

## API & Protocol Libraries

When working with modern network programmability and model-driven automation, libraries like **ncclient** and **requests** are invaluable. **ncclient** is essential for interacting with NETCONF-enabled devices, allowing engineers to retrieve and modify configurations in a structured manner. **Requests** is widely used for making REST API calls to platforms such as Cisco DNA Center, Cisco Meraki, and Catalyst Center, enabling automation of network management and monitoring tasks.

## Analysis & Visualization Tools

In addition to automation libraries, network engineers often rely on **Scapy** for packet analysis and manipulation. Scapy allows engineers to create, send, and capture packets for network troubleshooting, penetration testing, and protocol development. Furthermore, data analysis libraries like **Pandas** and **Matplotlib** are commonly used for processing and visualizing network data, making it easier to identify patterns and optimize network performance.

## Empowering Modern Network Operations

By leveraging these Python libraries, network engineers can automate repetitive tasks, enhance network monitoring, and integrate with software-defined networking (SDN) solutions. These tools empower engineers to work more efficiently, reduce manual errors, and keep up with the evolving demands of modern network infrastructures.

```python
# Example: Using Netmiko to configure multiple Cisco devices
from netmiko import ConnectHandler

# Device parameters
devices = [
 {
 'device_type': 'cisco_ios',
 'host': '192.168.1.1',
 'username': 'admin',
 'password': 'password',
 },
 {
 'device_type': 'cisco_ios',
 'host': '192.168.1.2',
 'username': 'admin',
 'password': 'password',
 }
]

# Configuration commands to apply
commands = [
 'interface GigabitEthernet0/1',
 'description AUTOMATED BY PYTHON',
 'ip address 10.10.10.1 255.255.255.0',
 'no shutdown'
]

# Connect to each device and apply configuration
for device in devices:
 try:
 # Establish connection
 connection = ConnectHandler(**device)
 
 # Enter configuration mode and apply commands
 output = connection.send_config_set(commands)
 
 # Print the output
 print(f"Configuration applied to {device['host']}:")
 print(output)
 
 # Disconnect from the device
 connection.disconnect()
 
 except Exception as e:
 print(f"Failed to configure {device['host']}: {str(e)}")
```

Essential Python libraries that empower network engineers to automate tasks, interact with devices, and analyze network data efficiently.

Python Libraries for Network Engineers

<img 
 src="/images/cisco_nvidia_ai.jpg" 
 alt="Cisco and NVIDIA Partnership for AI" 
 className="header-image"
 style={{
 width: '100%',
 maxHeight: '400px',
 objectFit: 'cover',
 marginBottom: '2rem'
 }}
/>

# Accelerating AI with Cisco and NVIDIA: Data Center Innovations

The partnership between Cisco and NVIDIA is delivering significant innovations for enterprise AI infrastructure. At the heart of this collaboration is the recently announced **Cisco Nexus Hyper Fabric**, a comprehensive solution combining NVIDIA GPUs, NVIDIA SmartNICs, Cisco Nexus 800 Gigabit Ethernet switching, and cloud-based management capabilities.

## Enterprise AI On-Premises

While many organizations begin their AI journey in the cloud, there are compelling reasons to bring AI workloads on-premises:

- **Data Privacy and Compliance**: Regulatory requirements or organizational policies may require keeping sensitive data within your own infrastructure
- **Cost Optimization**: As AI workloads scale, on-premises solutions can offer better economics
- **Performance Control**: Direct access to dedicated infrastructure without the variability of shared cloud resources

## Key Technologies Powering the Solution

The Cisco Nexus Hyper Fabric delivers several breakthrough technologies:

### Ultra-High-Speed Networking

- **800 Gigabit Ethernet** inside the data center for maximum throughput between compute nodes
- **1.2 Terabits per second per wavelength** connectivity between data centers, enabling massive scale across multiple physical buildings
- **Silicon photonics** and advanced optics optimized for AI workloads

### Simplified Management

The platform provides enterprise IT teams with:

- Cloud-based orchestration for the entire AI infrastructure
- Automated configuration and deployment tools
- Simplified cabling through intelligent mobile apps that guide installation

### Immersion Cooling Innovation

As AI data centers face power constraints, Cisco is pioneering immersion cooling technologies where entire systems—including network gear and GPUs—are submerged in specialized liquid to dramatically reduce power consumption while handling massive compute loads.

## Why This Matters

The scale of modern AI infrastructure is staggering. As one Cisco executive noted: "A single rack of GPUs has more bandwidth than the entire North American mobile cellular infrastructure." Managing this level of performance requires specialized networking expertise.

For enterprises looking to maintain control of their data while leveraging AI, the Cisco-NVIDIA partnership provides a pathway to deploy hyperscaler-grade infrastructure within their own environments.

## Looking Forward

With Cisco's $1 billion AI investment fund ($200 million already allocated to companies like Mistral AI and Scale AI) and continued focus on network innovation, we can expect further developments in this space as AI computing continues to evolve.

The message is clear: You cannot have AI without the network—and Cisco is ensuring that network is ready for the AI revolution.

Exploring Cisco's partnership with NVIDIA for on-premises AI computing, with a focus on the Nexus Hyper Fabric solution for enterprises wanting high-performance, private AI infrastructure.

Accelerating AI with Cisco and NVIDIA: Data Center Innovations


# Tutorials & How-To Guides

Welcome to our comprehensive collection of tutorials and how-to guides designed for network engineers, developers, and IT professionals. Whether you're just starting your automation journey or looking to expand your DevNetSecOps skills, you'll find practical, hands-on guidance here.

> **Note:** All tutorials include complete code samples and step-by-step instructions. If you encounter any issues or have questions, feel free to leave a comment or reach out via our contact page.

## Getting Started

New to network automation or programming? Start here with our beginner-friendly guides:

### [Python Basics for Network Engineers](https://pyneng.readthedocs.io/en/latest/index.html)
*Book | Beginner*  
Learn the Python fundamentals needed for network automation tasks

### [Setting Up Your Network Automation Lab](https://python-automation-book.readthedocs.io/en/1.0/09_lab/index.html)
*Guide | Intermediate*  
Create a virtualized environment to safely practice automation techniques

### [Introduction to Git for Network Engineers](https://realpython.com/python-git-github-intro/)
*Guide | Intermediate*  
Learn version control basics for managing your automation code

## Network Automation

Practical guides for automating your network infrastructure:

### [Automating Cisco Device Configuration with Netmiko](https://networkjourney.com/cisco-netmiko-scripting-with-examples-a-comprehensive-guide/)
*Guide and Examples | Intermediate*  
Use Python and Netmiko to configure multiple devices efficiently

### [NAPALM Network Automation Python: Introduction and Installation](https://www.youtube.com/watch?app=desktop&v=Mkc9dHg9rks&t=0s)
*Guide and instructions | Intermediate*  
Create a comprehensive device inventory using Python and NAPALM

### [Ansible for Network Configuration Management](https://www.redhat.com/en/technologies/management/ansible/configuration-management)
*Tutorial | Intermediate*  
Implement configuration as code with Ansible playbooks

## API & Programmability

Learn to leverage APIs and modern programmability features:

### [Getting Started with Cisco DNA Center API](https://developer.cisco.com/docs/dna-center/api-quick-start/)
*How To | Intermediate*  
Learn how to interact with DNA Center API for network management

### [Cisco NETCONF and REST Device Management API](https://developer.cisco.com/docs/cisco-netconf-and-rest-device-management-api-documentation/)
*Guide | Intermediate*  
Use RESTCONF to build programmable network applications

### [Meraki Dashboard API Automation](https://documentation.meraki.com/General_Administration/Other_Topics/Cisco_Meraki_Dashboard_API)
*Guide | Intermediate*  
Automate Meraki network management tasks through API integration

## Web Development for Network Tools

Create your own network management tools and dashboards:

### [From Data to Graph. a Web Journey With Flask and SQLite](https://www.instructables.com/From-Data-to-Graph-a-Web-Jorney-With-Flask-and-SQL/)
*How To | Intermediate*  
Create a simple but powerful web dashboard to visualize network data

### [A beginner's guide to network monitoring with Grafana and Prometheus](https://grafana.com/blog/2022/01/19/a-beginners-guide-to-network-monitoring-with-grafana-and-prometheus/)
*Setup | Intermediate*  
Implement real-time network monitoring using Python, WebSockets and Chart.js

### [Creating your First REST API with FastAPI](https://www.geeksforgeeks.org/creating-first-rest-api-with-fastapi/)
*How To | Intermediate*  
Build a high-performance API for network data access and management

## DevNetSecOps

Combine development, networking, and security with these advanced guides:

### [CI/CD Pipelines for Infrastructure Automation](https://www.youtube.com/watch?v=QzVSUL4j4Ts)
*Video Guide | Advanced*  
Implement continuous integration and deployment for network changes

### [Python for Automating Information Security](https://www.udemy.com/course/python-for-automating-information-security/?couponCode=LEARNNOWPLANS)
*Study Course | Advanced*  
Automate security audits and compliance checks across your network

### [Getting Started with Infrastructure-as-Code and Terraform](https://www.youtube.com/watch?v=wOuxBQNvrhs)
*Video Guide | Advanced*  
Manage network infrastructure using Terraform and Cisco providers

## Wireless Networking

Automate and optimize your wireless network:

### [Python for Wireless Network Automation](https://www.amazon.in/Python-Wireless-Network-Automation-Configuration-ebook/dp/B0DD44SY2W)
*Book | Intermediate*  
Use data analysis to optimize wireless network performance

### [Cisco WLC Pythonizer](https://developer.cisco.com/codeexchange/github/repo/consulttelecom/cisco-wlc-pythonizer/)
*Guide | Intermediate*  
Build scripts to automate Wireless LAN Controller configurations

## Have a Tutorial Request?

> **Tip:** Is there a specific tutorial or guide you'd like to see? Let us know! We're always looking for new ideas to help you on your automation journey.

## Resources

Need more resources for your learning journey? Check out these additional materials:

- [Python for Network Engineers Book](https://www.amazon.com/PYTHON-NETWORK-ENGINEERS-Networking-Operations-ebook/dp/B0DSLJ9MCF?dib=eyJ2IjoiMSJ9.3WGpY5PAGt8xwdVwns0DwkQQiGCPvlD9rGL_rnJaHyADnxgVpS32_VsRR_abUt5JSm64DvNkxIshfUOqrPtNVANvWJaBplfKVfysSiMsp5tePodvO7YTyPiqcyDz07Mw0JSgYrFlSvfYnR7jiUvMX2KSSjJUh_eRjw4CanqZpM6fGdVAe15V0_I4j68PIhqqCLy3Di8E8GmrSaRtjzpbaKG_MWab6fnIbk3b7K7J5p8.uSgEluj6E4IvB-I-Av3D5wd8O6Y9vb2ENq8ON5PF0RM&dib_tag=se&keywords=python+for+network+engineers&qid=1742008280&sr=8-5)
- [Cisco DevNet Learning Resources](https://developer.cisco.com/learning/)
- [Network Automation Forum](https://networkautomation.forum/)
- [Kirk Byers - Python for Network Engineers](https://pynet.twb-tech.com/)

Happy learning!

Practical step-by-step guides and tutorials covering network automation, Python, APIs, Cisco technologies, and more for engineers at all skill levels.

Tutorials & How-To Guides

# JavaScript Automation Example

Here's a simple script that automates file operations:

<CodePlayground 
 language="javascript"
 initialCode={`// A simple example of file processing automation
const processData = (data) => {
 // Split the data by lines
 const lines = data.split('\\n');
 
 // Filter out empty lines
 const nonEmptyLines = lines.filter(line => line.trim() !== '');
 
 // Extract values from each line
 const processedData = nonEmptyLines.map(line => {
 const [key, value] = line.split(':');
 return {
 key: key.trim(),
 value: value.trim()
 };
 });
 
 console.log('Processed data:', processedData);
 return processedData;
};

// Sample data
const sampleData = 
\`name: John Doe
email: john@example.com
role: DevOps Engineer
skills: Kubernetes, Docker, Terraform\`;

// Process the sample data
const result = processData(sampleData);
console.log('Number of entries:', result.length);`}
 theme="dark"
 height="400px"
/>

Try modifying the sample data or the processing function to see how the results change!

Learn how to automate tasks with JavaScript

Working with JavaScript Automation


# Exploring Cisco DevNet: The Developer Ecosystem for Network Automation and Security

## Introduction

In today's rapidly evolving technology landscape, automation and security are at the forefront of innovation. Cisco DevNet, the company's developer ecosystem, serves as a gateway for network engineers, software developers, and security professionals to explore the vast potential of automation, programmability, and DevNetSecOps. This platform not only provides an extensive set of tools and resources but also fosters collaboration among professionals aiming to enhance their networking skills through automation.

## What is Cisco DevNet?

Cisco DevNet (developer.cisco.com) is Cisco’s developer ecosystem designed to help professionals build applications and integrations with Cisco products and platforms. It provides a wealth of resources, including APIs, learning labs, sandboxes, and community forums. DevNet caters to a wide audience, from network engineers looking to automate configurations to developers building applications that interact with Cisco’s security and networking solutions.

### Key Features of DevNet:
1. **APIs & SDKs** – Access to a rich set of APIs across Cisco’s portfolio, including networking, security, collaboration, and cloud.
2. **Learning Labs** – Hands-on tutorials covering automation, security, networking, and software development.
3. **Sandboxes** – Virtual environments where users can test and deploy automation scripts without affecting production networks.
4. **DevNet Certifications** – Industry-recognized certifications focused on network automation and software-defined networking (SDN).
5. **Community & Support** – Forums, blogs, and events to engage with industry experts and peers.

## Learning & Utilizing DevNet Tools

One of the standout aspects of DevNet is its focus on education. Whether you're a beginner or an experienced professional, DevNet offers structured learning paths to help users master automation and network programmability.

- **DevNet Learning Tracks**: These structured courses cover various topics, including Python for network automation, API interactions, and security automation.
- **DevNet Sandboxes**: Free access to Cisco’s virtualized labs allows professionals to experiment with configurations and automation scripts in a risk-free environment.
- **DevNet Express Events**: Hands-on workshops designed to accelerate knowledge in network automation and security.
- **Code Exchange**: A repository of shared scripts, projects, and automation templates to help kickstart automation initiatives.

## How DevNet Ties into DevNetSecOps

With the growing adoption of network automation, security is an essential consideration. This is where DevNetSecOps comes into play—a fusion of development, networking, and security operations. DevNet provides resources that help professionals:
- Automate security policies and enforce compliance using tools like Cisco SecureX and DNA Center.
- Implement network segmentation and zero-trust models via programmable APIs.
- Integrate security automation into CI/CD pipelines for continuous compliance and threat mitigation.
- Utilize AI/ML-powered threat detection with Cisco's security analytics solutions.

## The Rapid Growth of Automation

Network automation is no longer a luxury—it is a necessity. As businesses scale their digital infrastructure, manual configurations and security measures cannot keep up with the complexity and speed of modern networks. Automation streamlines operations, reduces human errors, and enhances security enforcement at scale.

Cisco DevNet plays a crucial role in this transition by offering tools, learning resources, and certifications that empower professionals to automate workflows, deploy infrastructure as code (IaC), and integrate security into the automation pipeline.

## Conclusion

Cisco DevNet is a one-stop platform for network engineers and developers looking to embrace automation, programmability, and security in their workflows. By leveraging DevNet's vast resources, professionals can upskill, innovate, and drive the future of networking. Whether you're just starting or are an experienced engineer, DevNet provides the necessary tools to navigate the evolving landscape of network automation and security.

For more information, visit **[developer.cisco.com](https://developer.cisco.com)**.



Bridging the gap between Developers and Network Engineers

DevNet


## Initial Git push to repository

## 1. Navigate to Your Project Folder

cd /path/to/your/project

## 2. Initialize a Git Repository (if not already initialized)

git init

This creates a hidden .git folder inside your project, making it a Git repository.

## 3. Add a Remote Repository on GitHub

(a) Create a repository on GitHub:

    Go to GitHub.

    Click the + (plus sign) in the top-right corner and select New repository.

    Enter a name for your repository and click Create repository.

    Copy the provided remote URL (e.g., https://github.com/yourusername/your-repo.git).

(b) Link Your Local Repository to the GitHub Repository:

git remote add origin https://github.com/yourusername/your-repo.git

## 4. Stage and Commit Your Files

git add .

git commit -m "Initial commit"

## 5. Push to GitHub

If your repository has a default branch main (or master), push with:

git branch -M main  # Ensures your branch is named 'main'

git push -u origin main

If GitHub gives you an error like fatal: remote origin already exists, use:

git remote set-url origin https://github.com/yourusername/your-repo.git

Then try pushing again.

## Future Synchronization (Keeping Your Repo Updated)

After making changes in your project, use:

git add .

git commit -m "Describe your changes"

git push origin main

To pull the latest updates from GitHub (if working across multiple devices or with others):

git pull origin main


An overview on how to do an initial Git push when creating a new project locally.

Process for Initial Git push


## About Me

I’m an IT professional with a broad skill set in networking, system administration, and project management. My experience covers areas like routing and switching, network security, wireless and wired networking, VoIP, cloud technologies, and virtualization.

I’ve worked extensively with Cisco technologies, alongside other systems like Linux, macOS, and Windows. I also have a solid grasp of Python programming for automation tasks. I’m comfortable troubleshooting and optimizing LAN, WAN, and WLAN setups, designing network solutions, and managing infrastructure monitoring and performance.

Over the years, I’ve supported and maintained client IT environments, configured hardware like routers and switches, and worked on unified communications and video conferencing systems. I’ve also led teams, managed vendors, and contributed to technical documentation and standards.

My work involves balancing technical problem-solving with business needs, ensuring systems are reliable and secure while meeting practical goals. I enjoy adapting to new challenges, learning about emerging technologies, and finding ways to enhance efficiency—especially through automation.


An overview of my experience in networking, system administration, and automation.

About Me



## I'd love to hear from you.

## Contact Information

- **Email**: [info@ciscodev.co.za](mailto:info@ciscodev.co.za)
- **Location**: Cape Town, South Africa

Thank you for reaching out! I typically respond within 24-48 hours.