Inspiration

The challenges of knowledge transfer and retention in software engineering teams inspired us. New employees often struggle to quickly onboard and familiarize themselves with organizational policies, software codebases, and procedures - typically requiring them to repeatedly watch knowledge transfer recordings or reach out to senior team members. Similarly, existing employees frequently need access to design decisions, architectural information, or relevant material that might be scattered across emails, documentation, and chat messages or stored only in the minds of other engineers.

This universal pain point of knowledge fragmentation and the time-consuming nature of knowledge transfer led us to create Konveyor - a solution that leverages the power of Azure AI services to streamline and enhance the knowledge transfer process.

What it does

Konveyor is an intelligent knowledge transfer (KT) agent that helps new and existing employees quickly access and understand organizational information. It is a centralized interface where employees can ask natural language questions about codebases and documents to get accurate, tailored answers.

Key features include:

• Documentation Navigator: Helps users find specific information in documentation through semantic search and contextual understanding
• Code Understanding: Explains code snippets, architectural decisions, and implementation details to help engineers understand unfamiliar code
• Slack Integration: Seamlessly integrates with Slack, allowing users to interact with Konveyor directly in their existing workflow
• Contextual Follow-up: Maintains conversation context to enable natural follow-up questions
• Source Citation: Provides references to source materials, enabling users to explore topics in greater depth

Konveyor transforms the knowledge transfer experience from a time-consuming, fragmented process into a streamlined, accessible conversation with an AI assistant that understands your organization's specific context.

How we built it

We built Konveyor using a modern, cloud-native architecture leveraging several Azure AI services, all provisioned and managed through Terraform as Infrastructure as Code (IaC):

1. Azure OpenAI Service (azurerm_cognitive_account.openai): Powers the natural language understanding and generation capabilities with specific deployments:

   • GPT model deployment (azurerm_cognitive_deployment.gpt_deployment) for generating informative responses
   • Embeddings model deployment (azurerm_cognitive_deployment.embeddings) for creating vector representations of text

2. Azure Cognitive Search (azurerm_search_service.search): Provides the vector search infrastructure for semantic understanding of documentation and code

3. Azure Bot Service (azurerm_bot_service_azure_bot.bot): Manages the conversational interface and integration with Slack

4. Azure Document Intelligence (azurerm_cognitive_account.document_intelligence): Processes and extracts information from various document formats

5. Azure Cosmos DB for RAG implementation:

   • MongoDB API account (azurerm_cosmosdb_account.konveyor_db)
   • Database for conversations (azurerm_cosmosdb_mongo_database.konveyor_conversations)
   • Collections for conversations and messages (azurerm_cosmosdb_mongo_collection.conversations, azurerm_cosmosdb_mongo_collection.messages)

6. Azure Redis Cache (azurerm_redis_cache.konveyor_cache): Provides high-performance caching for frequently accessed data

7. Azure Storage (azurerm_storage_account.storage): Stores documents and other assets with dedicated containers (azurerm_storage_container.documents)

8. Azure Key Vault (azurerm_key_vault.vault): Securely stores and manages API keys and secrets

9. GitHub Copilot: Accelerated our development process by helping generate initial scripts code templates and suggesting implementations based on our requirements and issue-tracking

Our RAG (Retrieval-Augmented Generation) pipeline implementation:

• Processes and chunks documents and code
• Generates vector embeddings for semantic search
• Retrieves relevant context based on user queries
• Augments the LLM prompt with this context for accurate responses

We created a robust backend using Django to handle business logic, API endpoints, and service integration. The architecture prioritizes integration with existing developer tools rather than creating a standalone application, reducing adoption barriers and aligning with developer workflows.

Challenges we ran into

Throughout the development of Konveyor, we encountered several significant challenges:

1. Effective Document Chunking: Finding the optimal strategy for chunking documents to maintain context while enabling precise retrieval proved challenging. We experimented with various chunking approaches before finding a balance that preserved semantic meaning.

2. Code Understanding Complexity: Teaching the system to understand code structure and relationships between components requires sophisticated, prompt engineering and context management.

3. Integration Flexibility: Initially, we planned to use Microsoft Teams for the bot interface but encountered limitations with personal accounts during testing. We pivoted to Slack integration, which required refactoring our integration code but ultimately provided more flexibility for testing and demonstration.

4. Context Management: Implementing effective conversation state tracking to enable natural follow-up questions requires careful conversation flow and state management design.

5. Learning Curve: Working with Azure AI services beyond Azure OpenAI required learning new APIs and integration patterns, which added complexity to the development process.

6. Infrastructure Orchestration: Managing multiple Azure services with Terraform required careful planning of dependencies and resource configurations.

Accomplishments that we're proud of

Despite the challenges, we achieved several significant accomplishments:

1. Functional RAG Implementation: Successfully implemented a complete RAG pipeline that effectively retrieves relevant information from documentation and code repositories.

2. Seamless Slack Integration: Created a natural conversational interface in Slack that makes accessing organizational knowledge as simple as sending a message.

3. Code Understanding: Developed sophisticated code analysis capabilities that can explain code snippets, identify patterns, and provide architectural insights.

4. Follow-up Question Handling: Implemented context-aware conversation that maintains state between interactions, enabling natural follow-up questions.

5. Modular Architecture: Created a flexible, modular system that can be extended with additional features and integrations in the future.

6. Rapid Development: Completed a functional MVP within the tight timeframe of the hackathon, demonstrating the power of Azure services for rapid application development.

7. Infrastructure as Code: Successfully provisioned and managed all Azure resources using Terraform, ensuring reproducible deployments and configuration consistency.

What we learned

The development of Konveyor provided numerous valuable learning experiences:

1. RAG Implementation Techniques: We gained deep insights into effective RAG implementation, including document processing, chunking strategies, and context retrieval optimization.

2. Azure AI Services Integration: We learned how to effectively combine multiple Azure AI services into a cohesive solution, leveraging each service's strengths.

3. Bot Framework Development: We developed expertise in creating conversational interfaces using the Azure Bot Framework and integrating with messaging platforms.

4. Prompt Engineering: We refined our skills in prompt engineering to get the most effective responses from large language models, especially for technical content.

5. Infrastructure as Code: We improved our Terraform skills for managing cloud infrastructure, ensuring reproducible deployments.

6. GitHub Copilot Collaboration: We discovered how to use GitHub Copilot to accelerate development effectively, generating initial code structures based on our requirements and issue tracking.

7. GitHub Copilot Workspace: We have defined around 10 issues with 3 sub-issues each. Then, we used Github Copilot Workspace to generate initial code structures based on our requirements and issue tracking.

8. Agile Prioritization: We learned to prioritize features under tight time constraints effectively, focusing on delivering core value while deferring less critical capabilities.

What's next for Konveyor

Looking ahead, we have several exciting directions for Konveyor's evolution:

1. VS Code Extension: Develop a VS Code extension to bring Konveyor's capabilities directly into the IDE, allowing developers to query documentation and understand code without switching contexts.

2. Enhanced Code Analysis: Implement deeper code analysis capabilities, including dependency tracking, impact analysis, and performance insights.

3. Multi-Repository Support: Extend Konveyor to understand relationships between multiple repositories and provide cross-repository insights.

4. Personalized Responses: Implement user profiles to tailor responses based on role, experience level, and previous interactions.

5. Interactive Visualizations: Add support for generating and displaying architectural diagrams and code relationship visualizations.

6. Knowledge Gap Identification: Develop analytics to identify areas where documentation is lacking or outdated based on user queries.

7. Proactive Suggestions: Implement proactive knowledge sharing based on user context and activities.

8. Enhanced Infrastructure: Expand our Terraform modules to support additional Azure services and more sophisticated deployment patterns.

By continuing to develop Konveyor, we aim to transform how organizations manage, share, and access their collective knowledge, making onboarding faster and development more efficient for teams of all sizes.

Built With

• ai
• azure
• bot
• co-pilot
• db
• django
• python
• redis
• slack
• terraform