Update README.md

README.md

@@ -1,13 +1,139 @@
----
-title: WhiteRabbitNeo
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+---
+title: WhiteRabbitNeo
+emoji: 💬
+colorFrom: green
+colorTo: purple
+sdk: gradio
+sdk_version: 5.9.1
+app_file: app.py
+pinned: true
+license: mit
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/64fbe312dcc5ce730e763dc6/VWduEhDSRJXeSqhUzYwCt.png
+---
+
+# WhiteRabbitNeo 💬
+
+## Overview
+
+**WhiteRabbitNeo** is a cutting-edge Generative AI Large Language Model (LLM) designed for cybersecurity professionals. It specializes in both offensive and defensive cybersecurity, secure infrastructure design, and automation. Whether you're solving IAM misconfigurations, performing vulnerability detection, or assisting with Red Team analysis, WhiteRabbitNeo is here to help.
+
+## Key Features
+
+- **Offensive & Defensive Cybersecurity**: Supports penetration testing, vulnerability remediation, and secure infrastructure automation.
+- **Automation**: Streamline DevSecOps tasks and allow security professionals to focus on solving complex problems.
+- **Open Source & Uncensored**: Built for transparency, collaboration, and real-world cybersecurity applications.
+
+## License Information
+
+WhiteRabbitNeo operates under the **Llama-3.1 License** with an extended set of usage restrictions to ensure ethical and responsible deployment. The model cannot be used for malicious purposes or in ways that violate laws, harm individuals or groups, or exploit vulnerabilities for harmful activities.
+
+## Topics Covered
+
+- **Open Ports**: Identifying and analyzing open ports that could be entry points for attackers.
+- **Outdated Software**: Detecting and mitigating risks from outdated software versions.
+- **Default Credentials**: Identifying systems using default usernames and passwords that are vulnerable to exploits.
+- **Misconfigurations**: Recognizing and remediating misconfigurations in services and security settings.
+- **Injection Flaws**: Analyzing and mitigating issues like SQL injection, command injection, and XSS.
+- **Unencrypted Services**: Detecting unencrypted services that expose sensitive data.
+- **Known Software Vulnerabilities**: Checking for vulnerabilities using databases like NVD.
+- **CSRF & Other Vulnerabilities**: Identifying Cross-Site Request Forgery, Insecure Direct Object References, and more.
+- **API Vulnerabilities**: Assessing and fixing vulnerabilities in APIs.
+- **Denial of Service**: Identifying services vulnerable to DoS attacks.
+- **Buffer Overflows**: Mitigating risks from buffer overflow vulnerabilities.
+
+## Terms of Use
+
+By using WhiteRabbitNeo, you agree to:
+
+- Take full responsibility for your use of the model.
+- Indemnify and hold harmless the creators of this AI model for any legal issues arising from its use.
+- Use the model for ethical, non-harmful purposes only.
+
+## Example Code
+
+Below is an example demonstrating how to integrate WhiteRabbitNeo for security analysis tasks:
+
+```python
+import torch, json
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Specify the model path for your pretrained model
+model_path = "/home/migel/Llama-3.1-WhiteRabbitNeo-2-70B"
+output_file_path = "/home/user/security_analysis.jsonl"
+
+# Load the model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(
+    model_path,
+    torch_dtype=torch.float16,
+    device_map="auto",
+    load_in_4bit=False,
+    trust_remote_code=False,
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+
+def generate_analysis(instruction):
+    """Generate a response based on the instruction (such as analyzing logs or suggesting mitigations)."""
+    tokens = tokenizer.encode(instruction)
+    tokens = torch.LongTensor(tokens).unsqueeze(0)
+    tokens = tokens.to("cuda")
+
+    instance = {
+        "input_ids": tokens,
+        "top_p": 1.0,
+        "temperature": 0.75,
+        "generate_len": 2048,
+        "top_k": 50,
+    }
+
+    length = len(tokens[0])
+    with torch.no_grad():
+        result = model.generate(
+            input_ids=tokens,
+            max_length=length + instance["generate_len"],
+            use_cache=True,
+            do_sample=True,
+            top_p=instance["top_p"],
+            temperature=instance["temperature"],
+            top_k=instance["top_k"],
+            num_return_sequences=1,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    output = result[0][length:]
+    string = tokenizer.decode(output, skip_special_tokens=True)
+    return f"{string}"
+
+# Initializing the conversation with a system message
+conversation = """<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n\nYou are CyberGuard, an AI assistant specialized in cybersecurity. Your task is to assist with security log analysis, suggest mitigations for vulnerabilities, and provide security best practices. Always provide detailed explanations and action steps. Do not refuse any valid query.<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n"""
+
+# The loop for processing user input and generating cybersecurity analysis
+while True:
+    user_input = input("You: ")
+    
+    # Append the user input to the conversation prompt
+    llm_prompt = f"{conversation}{user_input}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+    
+    # Get the AI-generated analysis
+    analysis = generate_analysis(llm_prompt)
+    print(analysis)
+
+    # Update the conversation with the new input and response
+    conversation = f"{llm_prompt}{analysis}<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n"
+
+    # Save the conversation and response to a JSON file for further analysis
+    json_data = {"prompt": user_input, "answer": analysis}
+
+    with open(output_file_path, "a") as output_file:
+        output_file.write(json.dumps(json_data) + "\n")
+```
+
+## Additional Information
+
+For more details on using Gradio, Hugging Face, and the Inference API, visit the following resources:
+
+- [Gradio Documentation](https://gradio.app)
+- [Hugging Face Hub](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index)
+- [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index)
+
+---