Initial deployment of DevOps SLM Space

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.py linguist-language=Python
+*.md linguist-language=Markdown
+*.txt linguist-language=Text

README.md

@@ -1,12 +1,52 @@
 ---
-title: Devops Slm Chat
-emoji: 💻
-colorFrom: green
-colorTo: gray
+title: DevOps SLM - AI Assistant
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.46.0
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
+license: apache-2.0
+short_description: Interactive DevOps and Kubernetes AI Assistant
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# DevOps SLM - AI Assistant
+
+An interactive AI assistant specialized in DevOps, Kubernetes, Docker, and CI/CD operations.
+
+## Features
+
+- **💬 Chat Interface**: Ask questions about DevOps topics
+- **☸️ Kubernetes Generator**: Create deployment YAMLs
+- **🐳 Docker Generator**: Generate Dockerfiles
+- **🔄 CI/CD Designer**: Design pipeline configurations
+
+## Model
+
+This space uses the [DevOps-SLM model](https://huggingface.co/lakhera2023/devops-slm) - a specialized language model trained for DevOps tasks.
+
+## Usage
+
+1. **Chat Tab**: Ask any DevOps-related questions
+2. **Kubernetes Tab**: Generate deployment manifests
+3. **Docker Tab**: Create Dockerfiles for different applications
+4. **CI/CD Tab**: Design CI/CD pipeline configurations
+
+## Examples
+
+- "How do I create a Kubernetes deployment?"
+- "Generate a Dockerfile for a Node.js application"
+- "Design a CI/CD pipeline for microservices"
+- "Troubleshoot a failing pod in Kubernetes"
+
+## Model Information
+
+- **Parameters**: 494M
+- **Specialization**: DevOps, Kubernetes, Docker, CI/CD
+- **Base Model**: Custom transformer architecture
+- **License**: Apache 2.0
+
+## Support
+
+For questions or issues, please open an issue in the [model repository](https://huggingface.co/lakhera2023/devops-slm).

app.py

@@ -0,0 +1,288 @@
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import re
+
+class DevOpsSLM:
+    def __init__(self):
+        """Initialize the DevOps SLM."""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"🚀 Loading DevOps SLM on {self.device}...")
+        
+        # Load the model
+        self.model = AutoModelForCausalLM.from_pretrained(
+            "lakhera2023/devops-slm",
+            torch_dtype=torch.float16,
+            device_map="auto"
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained("lakhera2023/devops-slm")
+        
+        print("✅ DevOps SLM loaded successfully!")
+    
+    def generate_response(self, message, history, system_message, max_tokens, temperature):
+        """Generate a response from the DevOps SLM."""
+        if not message.strip():
+            return history, ""
+        
+        # Prepare messages
+        messages = [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": message}
+        ]
+        
+        # Apply chat template
+        text = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        # Tokenize
+        inputs = self.tokenizer([text], return_tensors="pt").to(self.device)
+        
+        # Generate response
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+                repetition_penalty=1.1
+            )
+        
+        # Decode response
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response = response[len(text):].strip()
+        
+        # Add to history
+        history.append([message, response])
+        
+        return history, ""
+    
+    def create_kubernetes_deployment(self, app_name, image, replicas, namespace):
+        """Generate Kubernetes deployment YAML."""
+        prompt = f"Create a Kubernetes deployment YAML for {app_name} using image {image} with {replicas} replicas in namespace {namespace}"
+        return self.generate_response(prompt, [], "You are a specialized DevOps assistant.", 300, 0.7)
+    
+    def create_dockerfile(self, app_type, base_image, requirements):
+        """Generate Dockerfile."""
+        prompt = f"Create a Dockerfile for a {app_type} application using base image {base_image}"
+        if requirements:
+            prompt += f" with these requirements: {requirements}"
+        return self.generate_response(prompt, [], "You are a specialized DevOps assistant.", 250, 0.7)
+    
+    def design_cicd_pipeline(self, project_type, deployment_target, tools):
+        """Design CI/CD pipeline."""
+        prompt = f"Design a CI/CD pipeline for a {project_type} project to deploy to {deployment_target}"
+        if tools:
+            prompt += f" using {tools}"
+        return self.generate_response(prompt, [], "You are a specialized DevOps assistant.", 400, 0.7)
+
+# Initialize the model
+devops_slm = DevOpsSLM()
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(
+        title="DevOps SLM - AI Assistant",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        .chat-message {
+            font-family: 'Courier New', monospace;
+        }
+        """
+    ) as interface:
+        
+        gr.Markdown("""
+        # 🚀 DevOps SLM - Specialized AI Assistant
+        
+        Welcome to the DevOps Specialized Language Model! This AI assistant is trained specifically for:
+        - **Kubernetes** operations and troubleshooting
+        - **Docker** containerization and best practices
+        - **CI/CD** pipeline design and implementation
+        - **Infrastructure** automation and management
+        - **DevOps** best practices and guidance
+        
+        Ask me anything about DevOps, and I'll provide expert guidance!
+        """)
+        
+        with gr.Tabs():
+            # Chat Tab
+            with gr.Tab("💬 Chat"):
+                chatbot = gr.Chatbot(
+                    label="DevOps Assistant",
+                    height=500,
+                    show_label=True,
+                    container=True,
+                    bubble_full_width=False
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Ask me about Kubernetes, Docker, CI/CD, or any DevOps topic...",
+                        lines=2,
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                with gr.Row():
+                    clear_btn = gr.Button("Clear Chat", variant="secondary")
+                
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    system_msg = gr.Textbox(
+                        label="System Message",
+                        value="You are a specialized DevOps and Kubernetes assistant. You help with DevOps tasks, Kubernetes operations, Docker containerization, CI/CD pipelines, and infrastructure management only.",
+                        lines=2
+                    )
+                    max_tokens = gr.Slider(
+                        minimum=50,
+                        maximum=500,
+                        value=200,
+                        step=10,
+                        label="Max Tokens"
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperature"
+                    )
+            
+            # Kubernetes Tab
+            with gr.Tab("☸️ Kubernetes"):
+                gr.Markdown("### Generate Kubernetes Manifests")
+                
+                with gr.Row():
+                    with gr.Column():
+                        k8s_app_name = gr.Textbox(label="Application Name", value="nginx")
+                        k8s_image = gr.Textbox(label="Docker Image", value="nginx:latest")
+                        k8s_replicas = gr.Number(label="Replicas", value=3, minimum=1, maximum=10)
+                        k8s_namespace = gr.Textbox(label="Namespace", value="default")
+                        k8s_generate_btn = gr.Button("Generate Deployment", variant="primary")
+                    
+                    with gr.Column():
+                        k8s_output = gr.Code(
+                            label="Generated YAML",
+                            language="yaml",
+                            lines=20
+                        )
+            
+            # Docker Tab
+            with gr.Tab("🐳 Docker"):
+                gr.Markdown("### Generate Dockerfile")
+                
+                with gr.Row():
+                    with gr.Column():
+                        docker_app_type = gr.Dropdown(
+                            choices=["Node.js", "Python", "Java", "Go", "React", "Vue.js", "Angular"],
+                            label="Application Type",
+                            value="Node.js"
+                        )
+                        docker_base_image = gr.Textbox(label="Base Image", value="node:18-alpine")
+                        docker_requirements = gr.Textbox(
+                            label="Requirements/Dependencies",
+                            placeholder="package.json, requirements.txt, etc.",
+                            lines=3
+                        )
+                        docker_generate_btn = gr.Button("Generate Dockerfile", variant="primary")
+                    
+                    with gr.Column():
+                        docker_output = gr.Code(
+                            label="Generated Dockerfile",
+                            language="dockerfile",
+                            lines=20
+                        )
+            
+            # CI/CD Tab
+            with gr.Tab("🔄 CI/CD"):
+                gr.Markdown("### Design CI/CD Pipeline")
+                
+                with gr.Row():
+                    with gr.Column():
+                        cicd_project_type = gr.Dropdown(
+                            choices=["Microservices", "Monolith", "Frontend", "Backend", "Full-stack"],
+                            label="Project Type",
+                            value="Microservices"
+                        )
+                        cicd_deployment_target = gr.Dropdown(
+                            choices=["Kubernetes", "Docker Swarm", "AWS ECS", "Azure Container Instances", "Google Cloud Run"],
+                            label="Deployment Target",
+                            value="Kubernetes"
+                        )
+                        cicd_tools = gr.Textbox(
+                            label="CI/CD Tools",
+                            placeholder="GitHub Actions, Jenkins, GitLab CI, etc.",
+                            value="GitHub Actions"
+                        )
+                        cicd_generate_btn = gr.Button("Design Pipeline", variant="primary")
+                    
+                    with gr.Column():
+                        cicd_output = gr.Code(
+                            label="Pipeline Configuration",
+                            language="yaml",
+                            lines=25
+                        )
+        
+        # Event handlers
+        def respond(message, history, system_msg, max_tokens, temperature):
+            if not message.strip():
+                return history, ""
+            
+            history, _ = devops_slm.generate_response(message, history, system_msg, max_tokens, temperature)
+            return history, ""
+        
+        def clear_chat():
+            return []
+        
+        def generate_k8s_deployment(app_name, image, replicas, namespace):
+            _, response = devops_slm.create_kubernetes_deployment(app_name, image, replicas, namespace)
+            return response[0][1] if response else "Failed to generate deployment"
+        
+        def generate_dockerfile(app_type, base_image, requirements):
+            _, response = devops_slm.create_dockerfile(app_type, base_image, requirements)
+            return response[0][1] if response else "Failed to generate Dockerfile"
+        
+        def generate_cicd_pipeline(project_type, deployment_target, tools):
+            _, response = devops_slm.design_cicd_pipeline(project_type, deployment_target, tools)
+            return response[0][1] if response else "Failed to generate pipeline"
+        
+        # Connect events
+        msg.submit(respond, [msg, chatbot, system_msg, max_tokens, temperature], [chatbot, msg])
+        send_btn.click(respond, [msg, chatbot, system_msg, max_tokens, temperature], [chatbot, msg])
+        clear_btn.click(clear_chat, outputs=chatbot)
+        
+        k8s_generate_btn.click(
+            generate_k8s_deployment,
+            [k8s_app_name, k8s_image, k8s_replicas, k8s_namespace],
+            k8s_output
+        )
+        
+        docker_generate_btn.click(
+            generate_dockerfile,
+            [docker_app_type, docker_base_image, docker_requirements],
+            docker_output
+        )
+        
+        cicd_generate_btn.click(
+            generate_cicd_pipeline,
+            [cicd_project_type, cicd_deployment_target, cicd_tools],
+            cicd_output
+        )
+    
+    return interface
+
+# Launch the interface
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+torch>=2.0.0
+transformers>=4.37.0
+accelerate>=0.20.0
+safetensors>=0.3.0