14 |
41 |
42 |
16 |
17 |
26 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
43 |
44 |
55 |
56 |
45 |
46 |
49 |
50 |
51 |
52 |
53 |
54 | History modal
47 | 48 |
57 |
58 |
69 |
70 |
59 |
60 |
63 |
64 |
65 |
66 |
67 |
68 | Agents modal
61 | 62 |
71 |
72 |
83 |
84 |
85 |
86 |
87 |
88 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/assets/images/stars.svg:
--------------------------------------------------------------------------------
1 |
4 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/assets/microsoft-logo.svg:
--------------------------------------------------------------------------------
1 |
13 |
--------------------------------------------------------------------------------
/src/backend/agents/fundamental_analysis.py:
--------------------------------------------------------------------------------
1 | from typing import List, Dict, Any
2 | import pandas as pd
3 | import yfinance as yf
4 |
5 | from autogen_core import AgentId
6 | from autogen_core import default_subscription
7 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
8 | from autogen_core.tools import FunctionTool, Tool
9 |
10 | from agents.base_agent import BaseAgent
11 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
12 | from helpers.fmputils import *
13 | from helpers.yfutils import *
14 | from helpers.analyzer import *
15 | from datetime import date, timedelta, datetime
16 |
17 | from typing import List, Dict, Any
18 | import os
19 | import requests
20 | from autogen_core.tools import FunctionTool, Tool
21 |
22 | async def fetch_and_analyze_fundamentals(ticker_symbol: str) -> Dict[str, Any]:
23 | """
24 | Fetch up to 5 years of fundamental data (Income Statement, Balance Sheet, Cash Flow)
25 | from Financial Modeling Prep, then compute ratios (ROE, ROA, placeholders for
26 | Altman Z-score, Piotroski F-score, etc.) for the given ticker.
27 |
28 | Returns a JSON-serializable dict with:
29 | - 5-year income statements
30 | - 5-year balance sheets
31 | - 5-year cash flows
32 | - A 'ratios_scores' section (ROE, ROA, AltmanZ, PiotroskiF)
33 | - Any notes or error messages
34 | """
35 |
36 | result = {
37 | "ticker_symbol": ticker_symbol,
38 | "financial_metrics": [],
39 | "ratings": {},
40 | "financial_scores": []
41 | }
42 |
43 | try:
44 | financialMetrics = fmpUtils.get_financial_metrics(ticker_symbol)
45 | ratings = fmpUtils.get_ratings(ticker_symbol)
46 | finacialScores = fmpUtils.get_financial_scores(ticker_symbol)
47 |
48 | result["financial_metrics"] = financialMetrics
49 | result["ratings"] = ratings
50 | result["financial_scores"] = finacialScores
51 |
52 | except Exception as e:
53 | result["notes"].append(f"Exception during fetch: {e}")
54 |
55 | return result
56 |
57 |
58 | def get_fundamental_analysis_tools() -> List[Tool]:
59 | """
60 | Return a list of Tools for the Fundamental Analysis Agent
61 | that fetch data from Financial Modeling Prep (FMP).
62 | """
63 | return [
64 | FunctionTool(
65 | fetch_and_analyze_fundamentals,
66 | description=(
67 | "Fetch fundamental data (Income, Balance, Cash Flow)"
68 | "and compute ratios (ROE, ROA, Altman Z, Piotroski, etc.) for a given ticker."
69 | ),
70 | )
71 | ]
72 |
73 | @default_subscription
74 | class FundamentalAnalysisAgent(BaseAgent):
75 | """
76 | A dedicated agent to perform fundamental analysis over the last ~5 years
77 | by pulling data from Financial Modeling Prep (FMP).
78 | Computes key ratios or scores (ROE, ROA, Altman Z, Piotroski, etc.).
79 | """
80 | def __init__(
81 | self,
82 | model_client: AzureOpenAIChatCompletionClient,
83 | session_id: str,
84 | user_id: str,
85 | memory: CosmosBufferedChatCompletionContext,
86 | fundamental_analysis_tools: List[Tool],
87 | fundamental_analysis_tool_agent_id: AgentId,
88 | ):
89 | super().__init__(
90 | "FundamentalAnalysisAgent",
91 | model_client,
92 | session_id,
93 | user_id,
94 | memory,
95 | fundamental_analysis_tools,
96 | fundamental_analysis_tool_agent_id,
97 | system_message=dedent(
98 | """
99 | You are a Fundamental Analysis Agent.
100 | Your role is to retrieve and analyze up to 5 years of fundamental data
101 | (cash flow, income statements, balance sheets) for a given ticker
102 | using the Financial Modeling Prep API.
103 | You also compute basic ratios like ROE, ROA, and placeholders for
104 | Altman Z-score and Piotroski F-score.
105 | Return the data and computations in structured JSON.
106 | """
107 | )
108 | )
--------------------------------------------------------------------------------
/deploy/macae-dev.bicep:
--------------------------------------------------------------------------------
1 | @description('Location for all resources.')
2 | param location string = resourceGroup().location
3 |
4 | @description('location for Cosmos DB resources.')
5 | // prompt for this as there is often quota restrictions
6 | param cosmosLocation string
7 |
8 | @description('Location for OpenAI resources.')
9 | // prompt for this as there is often quota restrictions
10 | param azureOpenAILocation string
11 |
12 | @description('A prefix to add to the start of all resource names. Note: A "unique" suffix will also be added')
13 | param prefix string = 'macae'
14 |
15 | @description('Tags to apply to all deployed resources')
16 | param tags object = {}
17 |
18 | @description('Principal ID to assign to the Cosmos DB contributor & Azure OpenAI user role, leave empty to skip role assignment. This is your ObjectID wihtin Entra ID.')
19 | param developerPrincipalId string
20 |
21 | var uniqueNameFormat = '${prefix}-{0}-${uniqueString(resourceGroup().id, prefix)}'
22 | var aoaiApiVersion = '2024-08-01-preview'
23 |
24 | resource openai 'Microsoft.CognitiveServices/accounts@2023-10-01-preview' = {
25 | name: format(uniqueNameFormat, 'openai')
26 | location: azureOpenAILocation
27 | tags: tags
28 | kind: 'OpenAI'
29 | sku: {
30 | name: 'S0'
31 | }
32 | properties: {
33 | customSubDomainName: format(uniqueNameFormat, 'openai')
34 | }
35 | resource gpt4o 'deployments' = {
36 | name: 'gpt-4o'
37 | sku: {
38 | name: 'GlobalStandard'
39 | capacity: 15
40 | }
41 | properties: {
42 | model: {
43 | format: 'OpenAI'
44 | name: 'gpt-4o'
45 | version: '2024-08-06'
46 | }
47 | versionUpgradeOption: 'NoAutoUpgrade'
48 | }
49 | }
50 | }
51 |
52 | resource aoaiUserRoleDefinition 'Microsoft.Authorization/roleDefinitions@2022-05-01-preview' existing = {
53 | name: '5e0bd9bd-7b93-4f28-af87-19fc36ad61bd' //'Cognitive Services OpenAI User'
54 | }
55 |
56 | resource devAoaiRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = if(!empty(trim(developerPrincipalId))) {
57 | name: guid(developerPrincipalId, openai.id, aoaiUserRoleDefinition.id)
58 | scope: openai
59 | properties: {
60 | principalId: developerPrincipalId
61 | roleDefinitionId: aoaiUserRoleDefinition.id
62 | principalType: 'User'
63 | }
64 | }
65 |
66 | resource cosmos 'Microsoft.DocumentDB/databaseAccounts@2024-05-15' = {
67 | name: format(uniqueNameFormat, 'cosmos')
68 | location: cosmosLocation
69 | tags: tags
70 | kind: 'GlobalDocumentDB'
71 | properties: {
72 | databaseAccountOfferType: 'Standard'
73 | enableFreeTier: false
74 | locations: [
75 | {
76 | failoverPriority: 0
77 | locationName: cosmosLocation
78 | }
79 | ]
80 | }
81 |
82 | resource contributorRoleDefinition 'sqlRoleDefinitions' existing = {
83 | name: '00000000-0000-0000-0000-000000000002'
84 | }
85 |
86 | resource devRoleAssignment 'sqlRoleAssignments' = if(!empty(trim(developerPrincipalId))) {
87 | name: guid(developerPrincipalId, contributorRoleDefinition.id)
88 | properties: {
89 | principalId: developerPrincipalId
90 | roleDefinitionId: contributorRoleDefinition.id
91 | scope: cosmos.id
92 | }
93 | }
94 |
95 | resource autogenDb 'sqlDatabases' = {
96 | name: 'autogen'
97 | properties: {
98 | resource: {
99 | id: 'autogen'
100 | createMode: 'Default'
101 | }
102 | options: {
103 | throughput: 400
104 | }
105 | }
106 |
107 | resource memoryContainer 'containers' = {
108 | name: 'memory'
109 | properties: {
110 | resource: {
111 | id: 'memory'
112 | partitionKey: {
113 | kind: 'Hash'
114 | version: 2
115 | paths: [
116 | '/session_id'
117 | ]
118 | }
119 | }
120 | }
121 | }
122 | }
123 | }
124 |
125 |
126 |
127 | output COSMOSDB_ENDPOINT string = cosmos.properties.documentEndpoint
128 | output COSMOSDB_DATABASE string = cosmos::autogenDb.name
129 | output COSMOSDB_CONTAINER string = cosmos::autogenDb::memoryContainer.name
130 | output AZURE_OPENAI_ENDPOINT string = openai.properties.endpoint
131 | output AZURE_OPENAI_DEPLOYMENT_NAME string = openai::gpt4o.name
132 | output AZURE_OPENAI_API_VERSION string = aoaiApiVersion
133 |
134 |
--------------------------------------------------------------------------------
/src/backend/helpers/summarizeutils.py:
--------------------------------------------------------------------------------
1 | import os
2 | import requests
3 | import json
4 | import pandas as pd
5 | from datetime import date, timedelta, datetime
6 | from typing import Annotated
7 |
8 | SavePathType = Annotated[str, "File path to save data. If None, data is not saved."]
9 |
10 | def summarize(description: str) -> str:
11 | try:
12 | print("*"*35)
13 | print("Calling summarize")
14 | print("*"*35)
15 | AZURE_OPENAI_DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
16 | AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION")
17 | AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
18 |
19 | url = f"{AZURE_OPENAI_ENDPOINT}/openai/deployments/{AZURE_OPENAI_DEPLOYMENT_NAME}/chat/completions?api-version={AZURE_OPENAI_API_VERSION}"
20 | headers = {
21 | 'api-key': os.getenv("AZURE_OPENAI_KEY"),
22 | "Content-Type": "application/json",
23 | }
24 |
25 | # Payload for the request
26 | payload = {
27 | "messages": [
28 | {
29 | "role": "system",
30 | "content": [
31 | {
32 | "type": "text",
33 | "text": "You are an AI assistant that will summarize the user input. You will not answer questions or respond to statements that are focused about"
34 | }
35 | ]
36 | },
37 | {
38 | "role": "user",
39 | "content": description
40 | }
41 | ],
42 | "temperature": 0.7,
43 | "top_p": 0.95,
44 | "max_tokens": 1200
45 | }
46 | # Send request
47 | response_json = requests.post(url, headers=headers, json=payload)
48 | return json.loads(response_json.text)['choices'][0]['message']['content']
49 | except Exception as e:
50 | return "I am sorry, I am unable to summarize the input at this time."
51 |
52 | def summarizeTopic(description: str, topic:str) -> str:
53 | try:
54 | print("*"*35)
55 | print("Calling summarizeTopic")
56 | print("*"*35)
57 | AZURE_OPENAI_DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
58 | AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION")
59 | AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
60 |
61 | url = f"{AZURE_OPENAI_ENDPOINT}/openai/deployments/{AZURE_OPENAI_DEPLOYMENT_NAME}/chat/completions?api-version={AZURE_OPENAI_API_VERSION}"
62 | headers = {
63 | 'api-key': os.getenv("AZURE_OPENAI_KEY"),
64 | "Content-Type": "application/json",
65 | }
66 |
67 | # Payload for the request
68 | payload = {
69 | "messages": [
70 | {
71 | "role": "system",
72 | "content": [
73 | {
74 | "type": "text",
75 | "text": f"You are an AI assistant that will summarize the user input on a {topic}. You will not answer questions or respond to statements that are focused about"
76 | }
77 | ]
78 | },
79 | {
80 | "role": "user",
81 | "content": description
82 | }
83 | ],
84 | "temperature": 0.7,
85 | "top_p": 0.95,
86 | "max_tokens": 1200
87 | }
88 | # Send request
89 | response_json = requests.post(url, headers=headers, json=payload)
90 | print("response_json", response_json.text)
91 | return json.loads(response_json.text)['choices'][0]['message']['content']
92 | except Exception as e:
93 | return "I am sorry, I am unable to summarize the topic at this time."
94 |
95 | def get_next_weekday(date):
96 |
97 | if not isinstance(date, datetime):
98 | date = datetime.strptime(date, "%Y-%m-%d")
99 |
100 | if date.weekday() >= 5:
101 | days_to_add = 7 - date.weekday()
102 | next_weekday = date + timedelta(days=days_to_add)
103 | return next_weekday
104 | else:
105 | return date
106 |
107 | async def save_output(data: pd.DataFrame, tag: str, save_path: SavePathType = None) -> None:
108 | if save_path:
109 | await data.to_csv(save_path)
110 | print(f"{tag} saved to {save_path}")
111 |
112 |
113 | def get_current_date():
114 | return date.today().strftime("%Y-%m-%d")
--------------------------------------------------------------------------------
/.github/workflows/codeql.yml:
--------------------------------------------------------------------------------
1 | # For most projects, this workflow file will not need changing; you simply need
2 | # to commit it to your repository.
3 | #
4 | # You may wish to alter this file to override the set of languages analyzed,
5 | # or to provide custom queries or build logic.
6 | #
7 | # ******** NOTE ********
8 | # We have attempted to detect the languages in your repository. Please check
9 | # the `language` matrix defined below to confirm you have the correct set of
10 | # supported CodeQL languages.
11 | #
12 | name: "CodeQL Advanced"
13 |
14 | on:
15 | push:
16 | branches: [ "main", "dev", "demo" ]
17 | pull_request:
18 | branches: [ "main", "dev", "demo" ]
19 | schedule:
20 | - cron: '44 20 * * 2'
21 |
22 | jobs:
23 | analyze:
24 | name: Analyze (${{ matrix.language }})
25 | # Runner size impacts CodeQL analysis time. To learn more, please see:
26 | # - https://gh.io/recommended-hardware-resources-for-running-codeql
27 | # - https://gh.io/supported-runners-and-hardware-resources
28 | # - https://gh.io/using-larger-runners (GitHub.com only)
29 | # Consider using larger runners or machines with greater resources for possible analysis time improvements.
30 | runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
31 | permissions:
32 | # required for all workflows
33 | security-events: write
34 |
35 | # required to fetch internal or private CodeQL packs
36 | packages: read
37 |
38 | # only required for workflows in private repositories
39 | actions: read
40 | contents: read
41 |
42 | strategy:
43 | fail-fast: false
44 | matrix:
45 | include:
46 | - language: javascript-typescript
47 | build-mode: none
48 | - language: python
49 | build-mode: none
50 | # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
51 | # Use `c-cpp` to analyze code written in C, C++ or both
52 | # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
53 | # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
54 | # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
55 | # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
56 | # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
57 | # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
58 | steps:
59 | - name: Checkout repository
60 | uses: actions/checkout@v4
61 |
62 | # Initializes the CodeQL tools for scanning.
63 | - name: Initialize CodeQL
64 | uses: github/codeql-action/init@v3
65 | with:
66 | languages: ${{ matrix.language }}
67 | build-mode: ${{ matrix.build-mode }}
68 | # If you wish to specify custom queries, you can do so here or in a config file.
69 | # By default, queries listed here will override any specified in a config file.
70 | # Prefix the list here with "+" to use these queries and those in the config file.
71 |
72 | # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
73 | # queries: security-extended,security-and-quality
74 |
75 | # If the analyze step fails for one of the languages you are analyzing with
76 | # "We were unable to automatically build your code", modify the matrix above
77 | # to set the build mode to "manual" for that language. Then modify this step
78 | # to build your code.
79 | # ℹ️ Command-line programs to run using the OS shell.
80 | # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
81 | - if: matrix.build-mode == 'manual'
82 | shell: bash
83 | run: |
84 | echo 'If you are using a "manual" build mode for one or more of the' \
85 | 'languages you are analyzing, replace this with the commands to build' \
86 | 'your code, for example:'
87 | echo ' make bootstrap'
88 | echo ' make release'
89 | exit 1
90 |
91 | - name: Perform CodeQL Analysis
92 | uses: github/codeql-action/analyze@v3
93 | with:
94 | category: "/language:${{matrix.language}}"
95 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/assets/theme.css:
--------------------------------------------------------------------------------
1 | :root {
2 | --bulma-link-h: 200deg;
3 | --bulma-info-s: 0%;
4 | --bulma-link-l: 0%;
5 |
6 | --bulma-info-h: 237deg;
7 | --bulma-info-s: 80%;
8 | --bulma-info-l: 60%;
9 |
10 | --bulma-focus-h: 237deg;
11 | --bulma-focus-s: 80%;
12 | --bulma-focus-l: 60%;
13 |
14 | --bulma-scheme-h: 200;
15 | --bulma-scheme-s: 0%;
16 |
17 | --bulma-soft-l: 80%;
18 | --bulma-bold-l: 0%;
19 |
20 | --bulma-family-primary: ui-sans-serif, -apple-system, system-ui, Segoe UI, Helvetica, Apple Color Emoji, Arial, sans-serif, Segoe UI Emoji, Segoe UI Symbol;
21 | --bulma-family-secondary: ui-sans-serif, -apple-system, system-ui, Segoe UI, Helvetica, Apple Color Emoji, Arial, sans-serif, Segoe UI Emoji, Segoe UI Symbol;
22 |
23 | --bulma-body-background-color: hsl(0, 100%, 100%);
24 | --bulma-body-color: rgb(74, 74, 74);
25 | --bulma-strong-color: hsl(0, 0%, 0%);
26 | --bulma-control-radius: 1000px;
27 | --bulma-info-invert-l: 98%;
28 |
29 | --bulma-success-h: 134deg;
30 | --bulma-success-s: 61%;
31 | --bulma-success-l: 41%;
32 | --bulma-success-invert-l: 98%;
33 |
34 | --bulma-danger-h: 354deg;
35 | --bulma-danger-s: 70%;
36 | --bulma-danger-l: 54%;
37 | }
38 |
39 | .card {
40 | --bulma-card-color: rgb(74, 74, 74);
41 | --bulma-card-shadow: rgba(51, 51, 51, 0.05) 0px 1px 2px 0px,
42 | rgba(51, 51, 51, 0.05) 0px 2px 4px 0px,
43 | rgb(214, 217, 224) 0px 0px 0px 1px inset;
44 | --bulma-card-header-shadow: 0;
45 | }
46 |
47 | .card.is-hoverable {
48 | transition: all 0.2s ease-in-out;
49 | }
50 |
51 | .card.is-hoverable:hover {
52 | cursor: pointer;
53 | transform: translateY(-2px);
54 | --bulma-card-shadow: 0 0 2px rgba(0, 0, 0, 0.12),
55 | 0 4px 8px rgba(0, 0, 0, 0.14),
56 | rgb(70, 79, 235) 0px 0px 0px 1px inset;
57 | }
58 |
59 | .media {
60 | --bulma-media-border-size: 0;
61 | }
62 |
63 | .modal-card-head {
64 | box-shadow: 0px 1px 1px 0px rgb(214, 217, 224);
65 | }
66 |
67 | .modal {
68 | --bulma-modal-background-background-color: hsla(0, 0%, 0%, 0.5);
69 | --bulma-modal-card-head-background-color: hsl(0, 0%, 100%);
70 | --bulma-modal-card-title-color: hsl(0, 0%, 0%);
71 | --bulma-modal-card-foot-background-color: hsl(0, 0%, 100%);
72 | --bulma-modal-card-body-background-color: hsl(0, 0%, 100%);
73 | }
74 |
75 | .box {
76 | --bulma-box-color: hsl(var(--bulma-menu-item-h), var(--bulma-menu-item-s), var(--bulma-menu-item-color-l));
77 | --bulma-box-shadow: rgb(214, 217, 224) 0px 0px 0px 1px;
78 | }
79 |
80 | .panel {
81 | --bulma-panel-shadow: rgb(214, 217, 224) 0px 0px 0px 1px;
82 | --bulma-panel-block-hover-background-color: hsl(0, 0%, 100%);
83 | }
84 |
85 | .tabs {
86 | --bulma-tabs-link-active-border-bottom-color: hsl(0, 0%, 0%);
87 | --bulma-tabs-link-active-color: hsl(0, 0%, 0%);
88 | }
89 |
90 | .tag {
91 | border-radius: var(--bulma-control-radius);
92 | font-weight: 500;
93 | }
94 |
95 | .menu-label {
96 | --bulma-menu-label-color: hsl(0, 0%, 0%);
97 | --bulma-menu-label-font-size: .85rem;
98 | text-transform: none;
99 | font-weight: 500;
100 | letter-spacing: 0;
101 | }
102 |
103 | .menu-list i {
104 | color: hsl(0, 0%, 0%);
105 | }
106 |
107 | .title {
108 | font-weight: 700;
109 | color: hsl(0, 0%, 0%);
110 | }
111 |
112 | .button {
113 | --bulma-button-ghost-color: hsl(0, 0%, 0%);
114 | }
115 |
116 | .modal {
117 | --bulma-modal-card-title-size: 1.15rem;
118 | --bulma-modal-card-head-padding: 1rem 2rem;
119 | }
120 |
121 | .modal-card-title {
122 | font-weight: 600;
123 | }
124 |
125 | .modal-card-head {
126 | display: flex;
127 | align-items: center;
128 | }
129 |
130 | .modal-card-head .button {
131 | --bulma-button-padding-horizontal: 0.68rem;
132 | }
133 |
134 | .modal-card-head .button i {
135 | margin-top: 1px;
136 | }
137 |
138 | .dropdown-content {
139 | padding: var(--bulma-dropdown-content-padding-bottom);
140 | box-shadow: var(--bulma-dropdown-content-shadow), rgb(214, 217, 224) 0px 0px 0px 1px inset;
141 | }
142 |
143 | .dropdown-content a.dropdown-item {
144 | border-radius: 0.25rem;
145 | }
146 |
147 | .input:focus,
148 | .input:focus-within,
149 | .is-focused.input,
150 | .is-focused.textarea,
151 | .select select.is-focused,
152 | .select select:focus,
153 | .select select:focus-within,
154 | .textarea:focus,
155 | .textarea:focus-within {
156 | border-color: hsl(var(--bulma-input-focus-h), var(--bulma-input-focus-s), var(--bulma-input-focus-l));
157 | box-shadow: var(--bulma-input-focus-shadow-size) hsla(var(--bulma-input-focus-h), var(--bulma-input-focus-s), var(--bulma-input-focus-l), var(--bulma-input-focus-shadow-alpha));
158 | }
159 |
160 | .progress::-webkit-progress-value {
161 | transition: width 0.5s ease;
162 | }
--------------------------------------------------------------------------------
/src/backend/Playground.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "from typing import List\n",
10 | "\n",
11 | "from autogen_core import AgentId\n",
12 | "from autogen_core import default_subscription\n",
13 | "from autogen_ext.models.openai import AzureOpenAIChatCompletionClient\n",
14 | "from autogen_core.tools import FunctionTool, Tool\n",
15 | "from typing_extensions import Annotated\n",
16 | "\n",
17 | "from agents.base_agent import BaseAgent\n",
18 | "from context.cosmos_memory import CosmosBufferedChatCompletionContext\n",
19 | "from helpers.fmputils import *\n",
20 | "from helpers.yfutils import *\n",
21 | "from datetime import date, timedelta, datetime\n",
22 | "from helpers.summarizeutils import summarize, summarizeTopic\n",
23 | "from helpers.analyzer import *\n",
24 | "from helpers.reports import ReportLabUtils\n",
25 | "from helpers.charting import ReportChartUtils\n",
26 | "from azure.identity import ClientSecretCredential, DefaultAzureCredential\n",
27 | "from azure.storage.blob import BlobServiceClient, ContentSettings, generate_blob_sas\n",
28 | "from config import Config\n",
29 | "import uuid\n",
30 | "from helpers.azureblob import azureBlobApi"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": 5,
36 | "metadata": {},
37 | "outputs": [],
38 | "source": [
39 | "async def copyReport(tenantId, clientId, clientSecret, blobAccountName, downloadPath, blobName, openAiBlobContainer):\n",
40 | " try:\n",
41 | " with open(downloadPath, \"rb\") as file:\n",
42 | " readBytes = file.read()\n",
43 | " credentials = ClientSecretCredential(tenantId, clientId, clientSecret)\n",
44 | " blobService = BlobServiceClient(\n",
45 | " \"https://{}.blob.core.windows.net\".format(blobAccountName), credential=credentials)\n",
46 | " blobClient = blobService.get_blob_client(container=openAiBlobContainer, blob=blobName)\n",
47 | " blobClient.upload_blob(readBytes,overwrite=True)\n",
48 | " return blobClient.url\n",
49 | " except Exception as e:\n",
50 | " print(\"Error in copyReport: \", e)\n",
51 | " return None"
52 | ]
53 | },
54 | {
55 | "cell_type": "code",
56 | "execution_count": 7,
57 | "metadata": {},
58 | "outputs": [
59 | {
60 | "name": "stdout",
61 | "output_type": "stream",
62 | "text": [
63 | "Local File Name: reports\\MSFT_Equity_Research_report.pdf\n",
64 | "Blob File Name: b8990f6a-29e3-40c9-8ccf-98b1613ee2e4_MSFTEquity_Research_report.pdf\n",
65 | "Blob api key found successfully.\n",
66 | "Blob URL: https://astdnapubstor.blob.core.windows.net/reports/b8990f6a-29e3-40c9-8ccf-98b1613ee2e4_MSFTEquity_Research_report.pdf\n"
67 | ]
68 | }
69 | ],
70 | "source": [
71 | "ticker_symbol = \"MSFT\"\n",
72 | "\n",
73 | "blobFileName = \"{}_{}Equity_Research_report.pdf\".format(str(uuid.uuid4()), ticker_symbol)\n",
74 | "localFileName = \"reports\\\\{}_Equity_Research_report.pdf\".format(ticker_symbol)\n",
75 | "print(\"Local File Name: \", localFileName)\n",
76 | "print(\"Blob File Name: \", blobFileName)\n",
77 | "\n",
78 | "blobUrl = azureBlobApi.copyReport(\"reports\\\\{}_Equity_Research_report.pdf\".format(ticker_symbol), blobFileName)\n",
79 | "\n",
80 | "print(\"Blob URL: \", blobUrl)\n"
81 | ]
82 | },
83 | {
84 | "cell_type": "code",
85 | "execution_count": 2,
86 | "metadata": {},
87 | "outputs": [
88 | {
89 | "name": "stdout",
90 | "output_type": "stream",
91 | "text": [
92 | "****************\n",
93 | "reportDir: /app/backend/reports/\n",
94 | "****************\n"
95 | ]
96 | }
97 | ],
98 | "source": [
99 | "if Config.APP_IN_CONTAINER:\n",
100 | " reportDir = \"/app/backend/reports/\"\n",
101 | "else:\n",
102 | " reportDir = \"reports\\\\\"\n",
103 | "\n",
104 | "print(\"****************\")\n",
105 | "print(\"reportDir: \", reportDir)\n",
106 | "print(\"****************\")"
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": null,
112 | "metadata": {},
113 | "outputs": [],
114 | "source": []
115 | }
116 | ],
117 | "metadata": {
118 | "kernelspec": {
119 | "display_name": "Python 3",
120 | "language": "python",
121 | "name": "python3"
122 | },
123 | "language_info": {
124 | "codemirror_mode": {
125 | "name": "ipython",
126 | "version": 3
127 | },
128 | "file_extension": ".py",
129 | "mimetype": "text/x-python",
130 | "name": "python",
131 | "nbconvert_exporter": "python",
132 | "pygments_lexer": "ipython3",
133 | "version": "3.11.9"
134 | }
135 | },
136 | "nbformat": 4,
137 | "nbformat_minor": 2
138 | }
139 |
--------------------------------------------------------------------------------
/src/backend/agents/agentutils.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 | from autogen_core.models import (AssistantMessage)
4 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
5 | from pydantic import BaseModel
6 |
7 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
8 | from models.messages import Step
9 |
10 | common_agent_system_message = "If you do not have the information for the arguments of the function you need to call, do not call the function. Instead, respond back to the user requesting further information. You must not hallucinate or invent any of the information used as arguments in the function. For example, if you need to call a function that requires a delivery address, you must not generate 123 Example St. You must skip calling functions and return a clarification message along the lines of: Sorry, I'm missing some information I need to help you with that. Could you please provide the delivery address so I can do that for you?"
11 |
12 |
13 | async def extract_and_update_transition_states(
14 | step: Step,
15 | session_id: str,
16 | user_id: str,
17 | planner_dynamic_or_workflow: str,
18 | model_client: AzureOpenAIChatCompletionClient,
19 | ):
20 | """
21 | This function extracts the identified target state and transition from the LLM response and updates the step with the identified target state and transition. This is reliant on the agent_reply already being present.
22 | """
23 | planner_dynamic_or_workflow = "workflow"
24 | if planner_dynamic_or_workflow == "workflow":
25 |
26 | class FSMStateAndTransition(BaseModel):
27 | identifiedTargetState: str
28 | identifiedTargetTransition: str
29 |
30 | cosmos = CosmosBufferedChatCompletionContext(session_id or "", user_id)
31 | combined_LLM_messages = [
32 | AssistantMessage(content=step.action, source="GroupChatManager")
33 | ]
34 | combined_LLM_messages.extend(
35 | [AssistantMessage(content=step.agent_reply, source="AgentResponse")]
36 | )
37 | combined_LLM_messages.extend(
38 | [
39 | AssistantMessage(
40 | content="Based on the above conversation between two agents, I need you to identify the identifiedTargetState and identifiedTargetTransition values. Only return these values. Do not make any function calls. If you are unable to work out the next transition state, return ERROR.",
41 | source="GroupChatManager",
42 | )
43 | ]
44 | )
45 |
46 | # TODO - from local testing, this step is often causing the app to hang. It's unclear why- often the first time it fails when running a workflow that requires human input. If the app is manually restarted, it works the second time. However this is not consistent- sometimes it will work fine the first time. It may be the LLM generating some invalid characters which is causing errors on the JSON formatting. However, even when attempting a timeout and retry, the timeout with asnycio would never trigger. It's unclear what the issue is here.
47 | # Get the LLM response
48 | llm_temp_result = await model_client.create(
49 | combined_LLM_messages,
50 | extra_create_args={"response_format": FSMStateAndTransition},
51 | )
52 | content = llm_temp_result.content
53 |
54 | # Parse the LLM response
55 | parsed_result = json.loads(content)
56 | structured_plan = FSMStateAndTransition(**parsed_result)
57 |
58 | # update the steps
59 | step.identified_target_state = structured_plan.identifiedTargetState
60 | step.identified_target_transition = structured_plan.identifiedTargetTransition
61 |
62 | await cosmos.update_step(step)
63 | return step
64 |
65 |
66 | # async def set_next_viable_step_to_runnable(session_id):
67 | # cosmos = CosmosBufferedChatCompletionContext(session_id)
68 | # plan_with_steps = await cosmos.get_plan_with_steps(session_id)
69 | # if plan_with_steps.overall_status != PlanStatus.completed:
70 | # for step_object in plan_with_steps.steps:
71 | # if step_object.status not in [StepStatus.rejected, StepStatus.completed]:
72 | # step_object.runnable = True
73 | # await cosmos.update_step(step_object)
74 | # break
75 |
76 |
77 | # async def initiate_replanning(session_id):
78 | # from utils import handle_input_task_wrapper
79 |
80 | # cosmos = CosmosBufferedChatCompletionContext(session_id)
81 | # plan_with_steps = await cosmos.get_plan_with_steps(session_id)
82 | # input_task = InputTask(
83 | # session_id=plan_with_steps.session_id,
84 | # description=plan_with_steps.initial_goal,
85 | # planner_type=plan_with_steps.planner_type,
86 | # new_plan_or_replanning="replanning",
87 | # human_comments_on_overall_plan=plan_with_steps.human_comments_on_overall_plan,
88 | # planner_dynamic_or_workflow=plan_with_steps.planner_dynamic_or_workflow,
89 | # workflowName=plan_with_steps.workflowName,
90 | # )
91 | # await handle_input_task_wrapper(input_task)
92 |
--------------------------------------------------------------------------------
/TRANSPARENCY_FAQS.md:
--------------------------------------------------------------------------------
1 | # Multi-Agent: Custom Automation Engine – Solution Accelerator : Responsible AI FAQ
2 |
3 | ## What is the Multi Agent: Custom Automation Engine – Solution Accelerator?
4 | Multi Agent: Custom Automation Engine – Solution Accelerator is an open-source GitHub Repository that enables users to solve complex tasks using multiple agents. The accelerator is designed to be generic across business tasks. The user enters a task and a planning LLM formulates a plan to complete that task. The system then dynamically generates agents which can complete the task. The system also allows the user to create actions that agents can take (for example sending emails or scheduling orientation sessions for new employees). These actions are taken into account by the planner and dynamically created agents may be empowered to take these actions.
5 |
6 | ## What can the Multi Agent: Custom Automation Engine – Solution Accelerator do?
7 | The solution accelerator is designed to replace and enhance enterprise workflows and processes with intelligent automation. Agents can specialize in various functions and work together to achieve an objective as specified by the user. The accelerator will integrate seamlessly with existing systems and is designed to scale according to the needs of the customer. The system allows users to review, reorder and approve steps generated in a plan, ensuring human oversight. The system uses function calling with LLMs to perform actions, users can approve or modify these actions.
8 |
9 | ## What is/are Multi Agent: Custom Automation Engine – Solution Accelerator’s intended use(s)?
10 | This repository is to be used only as a solution accelerator following the open-source license terms listed in the GitHub repository. The example scenario’s intended purpose is to demonstrate how users can analyze and process audio files and call transcripts to help them work more efficiently and streamline their human made decisions.
11 |
12 | ## How was Multi Agent: Custom Automation Engine – Solution Accelerator evaluated? What metrics are used to measure performance?
13 | The evaluation process includes human review of the outputs, and tuned LLM prompts to produce relevant responses. It's worth noting that the system is designed to be highly customizable and can be tailored to fit specific business needs and use cases. As such, the metrics used to evaluate the system's performance may vary depending on the specific use case and business requirements.
14 |
15 | ## What are the limitations of Multi Agent: Custom Automation Engine – Solution Accelerator? How can users minimize the impact Multi Agent: Custom Automation Engine – Solution Accelerator’s limitations when using the system?
16 | The system allows users to review, reorder and approve steps generated in a plan, ensuring human oversight. The system uses function calling with LLMs to perform actions, users can approve or modify these actions. Users of the accelerator should review the system prompts provided and update as per their organizational guidance. Users should run their own evaluation flow either using the guidance provided in the GitHub repository or their choice of evaluation methods.
17 | Note that the Multi Agent: Custom Automation Engine – Solution Accelerator relies on the AutoGen Multi Agent framework. AutoGen has published their own [list of limitations and impacts](https://github.com/microsoft/autogen/blob/gaia_multiagent_v01_march_1st/TRANSPARENCY_FAQS.md#what-are-the-limitations-of-autogen-how-can-users-minimize-the-impact-of-autogens-limitations-when-using-the-system).
18 |
19 | ## What operational factors and settings allow for effective and responsible use of Multi Agent: Custom Automation Engine – Solution Accelerator?
20 | Effective and responsible use of the Multi Agent: Custom Automation Engine – Solution Accelerator depends on several operational factors and settings. The system is designed to perform reliably and safely across a range of business tasks that it was evaluated for. Users can customize certain settings, such as the planning language model used by the system, the types of tasks that agents are assigned, and the specific actions that agents can take (e.g., sending emails or scheduling orientation sessions for new employees). However, it's important to note that these choices may impact the system's behavior in real-world scenarios.
21 | For example, selecting a planning language model that is not well-suited to the complexity of the tasks may result in lower accuracy and performance. Similarly, assigning tasks that are outside the system's intended scope may lead to errors or incomplete results. Users can choose the LLM that is optimized for responsible use. The default LLM is GPT-4o which inherits the existing RAI mechanisms and filters from the LLM provider. Caching is enabled by default to increase reliability and control cost. We encourage developers to review [OpenAI’s Usage policies](https://openai.com/policies/usage-policies/) and [Azure OpenAI’s Code of Conduct](https://learn.microsoft.com/en-us/legal/cognitive-services/openai/code-of-conduct) when using GPT-40. To ensure effective and responsible use of the accelerator, users should carefully consider their choices and use the system within its intended scope.
--------------------------------------------------------------------------------
/src/frontend/wwwroot/task/employee.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
73 |
74 |
77 |
78 |
79 |
80 |
81 |
82 | Workflow modal
75 | 76 |
15 |
16 |
17 |
18 |
19 |
123 |
127 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
--------------------------------------------------------------------------------
/src/backend/config.py:
--------------------------------------------------------------------------------
1 | # config.py
2 | import logging
3 | import os
4 |
5 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
6 | from azure.cosmos.aio import CosmosClient
7 | from azure.identity.aio import (ClientSecretCredential, DefaultAzureCredential,
8 | get_bearer_token_provider)
9 | from dotenv import load_dotenv
10 |
11 | load_dotenv(".env", override=True)
12 |
13 |
14 | def GetRequiredConfig(name):
15 | #return os.environ[name]
16 | #print(f"GetRequiredConfig: {os.getenv(name)}")
17 | return os.getenv(name)
18 |
19 |
20 | def GetOptionalConfig(name, default=""):
21 | # if name in os.environ:
22 | # return os.environ[name]
23 | #print(f"GetOptionalConfig: {os.getenv(name)}")
24 | if os.getenv(name):
25 | return os.getenv(name)
26 | return default
27 |
28 |
29 | def GetBoolConfig(name):
30 | #return name in os.environ and os.environ[name].lower() in ["true", "1"]
31 | #return os.getenv(name) and os.getenv(name).lower() in ["true", "1"]
32 | if os.getenv(name):
33 | if os.getenv(name).lower() in ["true", "1"]:
34 | return True
35 | return False
36 |
37 |
38 | class Config:
39 | AZURE_TENANT_ID = GetOptionalConfig("AZURE_TENANT_ID")
40 | AZURE_CLIENT_ID = GetOptionalConfig("AZURE_CLIENT_ID")
41 | AZURE_CLIENT_SECRET = GetOptionalConfig("AZURE_CLIENT_SECRET")
42 |
43 | COSMOSDB_ENDPOINT = GetRequiredConfig("COSMOSDB_ENDPOINT")
44 | COSMOSDB_DATABASE = GetRequiredConfig("COSMOSDB_DATABASE")
45 | COSMOSDB_CONTAINER = GetRequiredConfig("COSMOSDB_CONTAINER")
46 |
47 | AZURE_OPENAI_DEPLOYMENT_NAME = GetRequiredConfig("AZURE_OPENAI_DEPLOYMENT_NAME")
48 | AZURE_OPENAI_API_VERSION = GetRequiredConfig("AZURE_OPENAI_API_VERSION")
49 | AZURE_OPENAI_ENDPOINT = GetRequiredConfig("AZURE_OPENAI_ENDPOINT")
50 | AZURE_OPENAI_API_KEY = GetOptionalConfig("AZURE_OPENAI_KEY")
51 |
52 | AZURE_BLOB_STORAGE_NAME = GetRequiredConfig("AZURE_BLOB_STORAGE_NAME")
53 | AZURE_BLOB_CONTAINER_NAME = GetRequiredConfig("AZURE_BLOB_CONTAINER_NAME")
54 |
55 | APP_IN_CONTAINER = GetBoolConfig("APP_IN_CONTAINER")
56 | FRONTEND_SITE_NAME = GetOptionalConfig("FRONTEND_SITE_NAME", "http://127.0.0.1:3000")
57 |
58 |
59 | __azure_credentials = DefaultAzureCredential()
60 | __comos_client = None
61 | __cosmos_database = None
62 | __aoai_chatCompletionClient = None
63 |
64 | def GetAzureCredentials():
65 | # If we have specified the credentials in the environment, use them (backwards compatibility)
66 | if all(
67 | [Config.AZURE_TENANT_ID, Config.AZURE_CLIENT_ID, Config.AZURE_CLIENT_SECRET]
68 | ):
69 | return ClientSecretCredential(
70 | tenant_id=Config.AZURE_TENANT_ID,
71 | client_id=Config.AZURE_CLIENT_ID,
72 | client_secret=Config.AZURE_CLIENT_SECRET,
73 | )
74 |
75 | # Otherwise, use the default Azure credential which includes managed identity
76 | return Config.__azure_credentials
77 |
78 | # Gives us a cached approach to DB access
79 | def GetCosmosDatabaseClient():
80 | # TODO: Today this is a single DB, we might want to support multiple DBs in the future
81 | if Config.__comos_client is None:
82 | Config.__comos_client = CosmosClient(
83 | Config.COSMOSDB_ENDPOINT, Config.GetAzureCredentials()
84 | )
85 |
86 | if Config.__cosmos_database is None:
87 | Config.__cosmos_database = Config.__comos_client.get_database_client(
88 | Config.COSMOSDB_DATABASE
89 | )
90 |
91 | return Config.__cosmos_database
92 |
93 | def GetTokenProvider(scopes):
94 | return get_bearer_token_provider(Config.GetAzureCredentials(), scopes)
95 |
96 | def GetAzureOpenAIChatCompletionClient(model_capabilities):
97 | if Config.__aoai_chatCompletionClient is not None:
98 | return Config.__aoai_chatCompletionClient
99 |
100 | #print(f"Config.AZURE_OPENAI_API_KEY: {Config.AZURE_OPENAI_API_KEY}")
101 | if Config.AZURE_OPENAI_API_KEY == "":
102 | # Use DefaultAzureCredential for auth
103 | Config.__aoai_chatCompletionClient = AzureOpenAIChatCompletionClient(
104 | azure_deployment=Config.AZURE_OPENAI_DEPLOYMENT_NAME,
105 | api_version=Config.AZURE_OPENAI_API_VERSION,
106 | azure_endpoint=Config.AZURE_OPENAI_ENDPOINT,
107 | azure_ad_token_provider=Config.GetTokenProvider(
108 | "https://cognitiveservices.azure.com/.default"
109 | ),
110 | model="gpt-4o",
111 | #model="o1-mini",
112 | model_capabilities=model_capabilities,
113 | temperature=0,
114 | )
115 | else:
116 | # Fallback behavior to use API key
117 | Config.__aoai_chatCompletionClient = AzureOpenAIChatCompletionClient(
118 | azure_deployment=Config.AZURE_OPENAI_DEPLOYMENT_NAME,
119 | api_version=Config.AZURE_OPENAI_API_VERSION,
120 | azure_endpoint=Config.AZURE_OPENAI_ENDPOINT,
121 | api_key=Config.AZURE_OPENAI_API_KEY,
122 | model="gpt-4o",
123 | #model="o1-mini",
124 | model_capabilities=model_capabilities,
125 | temperature=0,
126 | )
127 |
128 | return Config.__aoai_chatCompletionClient
129 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/home/home.css:
--------------------------------------------------------------------------------
1 | @import "../app.css";
2 |
3 | .container {
4 | inset: 0;
5 | min-height: 100vh;
6 | overflow-y: auto;
7 | }
8 |
9 | .section {
10 | min-width: 800px;
11 | z-index: 1;
12 | }
13 |
14 | .app-logo {
15 | width: 60px;
16 | margin: 0 auto;
17 | }
18 |
19 | .background {
20 | inset: 0;
21 | position: absolute;
22 | opacity: 0.1;
23 | overflow-y: hidden;
24 | }
25 |
26 | .description {
27 | color: Black;
28 | text-align: center;
29 |
30 | /* Web/Body 1 */
31 | font-family: "Segoe UI";
32 | font-size: 14px;
33 | font-style: normal;
34 | font-weight: 400;
35 | line-height: 20px; /* 142.857% */
36 | margin-bottom: 10px;
37 | }
38 |
39 | .title {
40 | color: var(
41 | --Light-Mode-Foreground-Neutral-Primary,
42 | var(--Foreground-Neutral-Primary, #111)
43 | );
44 | text-align: center;
45 | font-family: "Segoe UI";
46 | font-size: 32px;
47 | font-style: normal;
48 | font-weight: 700;
49 | line-height: 40px; /* 125% */
50 | }
51 |
52 | .assistants {
53 | text-align: center;
54 | font-family: "Segoe UI";
55 | font-size: 32px;
56 | font-style: normal;
57 | font-weight: 700;
58 | line-height: 40px; /* 125% */
59 |
60 | background: var(
61 | --Gradient-M365-Chat-Light-Accessible,
62 | linear-gradient(90deg, #464feb 10.42%, #8330e9 100%)
63 | );
64 | background-clip: text;
65 | -webkit-background-clip: text;
66 | -webkit-text-fill-color: transparent;
67 | }
68 |
69 | .orb {
70 | width: 50%;
71 | height: 50%;
72 | border-radius: 50%;
73 | filter: blur(50px);
74 | background: radial-gradient(circle);
75 | position: absolute;
76 | }
77 |
78 | .orb.one {
79 | bottom: -40%;
80 | left: 47.5%;
81 | background-color: rgba(70, 79, 235, 1);
82 | }
83 |
84 | .orb.two {
85 | bottom: -30%;
86 | left: 25%;
87 | background-color: rgb(18, 172, 149);
88 | z-index: 1;
89 | }
90 |
91 | .orb.three {
92 | bottom: -40%;
93 | left: 2.5%;
94 | background-color: rgb(199, 20, 184);
95 | }
96 |
97 | .new-task-control:has(> textarea:disabled)::before,
98 | .new-task-control:has(> textarea:disabled)::after {
99 | pointer-events: none;
100 | content: "";
101 | position: absolute;
102 | left: -2px;
103 | top: -2px;
104 | background: linear-gradient(
105 | 45deg,
106 | #fb0094,
107 | #0000ff,
108 | #fb0094,
109 | #0000ff,
110 | #fb0094,
111 | #0000ff,
112 | #fb0094,
113 | #0000ff
114 | );
115 | background-size: 400%;
116 | width: calc(100% + 4px);
117 | height: calc(100% + 4px);
118 | border-radius: var(--bulma-input-radius);
119 | opacity: 0.5;
120 | z-index: -1;
121 | animation: steam 20s linear infinite;
122 | }
123 |
124 | @keyframes steam {
125 | 0% {
126 | background-position: 0 0;
127 | }
128 |
129 | 50% {
130 | background-position: 400% 0;
131 | }
132 |
133 | 100% {
134 | background-position: 0 0;
135 | }
136 | }
137 |
138 | .new-task-control::after {
139 | filter: blur(25px);
140 | }
141 |
142 | .text-input-container {
143 | width: 950px;
144 | position: relative;
145 | border: 1px solid #ccc;
146 | border-radius: 8px;
147 | background-color: white;
148 | }
149 |
150 | textarea {
151 | width: 98%;
152 | padding: 16px 0px 0px 0px;
153 | border: none;
154 | border-radius: 8px 8px 0 0;
155 | font-size: 16px;
156 | line-height: 1.5;
157 | resize: none;
158 | outline: none;
159 | overflow: hidden;
160 | margin: 0 10px;
161 | align-items: center;
162 | background-color: white;
163 | }
164 | textarea:disabled {
165 | cursor: default;
166 | background-color: white;
167 | }
168 |
169 | /*Spinner start*/
170 | #spinnerLoader {
171 | display: flex;
172 | flex-direction: column;
173 | /* justify-content: center; */
174 | align-items: center;
175 | position: absolute;
176 | inset: 0;
177 | color: black;
178 | top: 30%;
179 | left: 50%;
180 | transform: translateX(-50%);
181 | /* background-color: rgb(247, 249, 251);*/
182 | z-index: 9999;
183 | font-weight: 500;
184 | }
185 |
186 | #spinnerLoader span::before {
187 | content: "Creating Tasks...";
188 | animation: spinLoaderAnimation infinite 3s linear;
189 | }
190 |
191 | @keyframes spinLoaderAnimation {
192 | 75% {
193 | content: "Agents are on it...";
194 | }
195 | }
196 |
197 | #spinnerLoader i {
198 | font-size: 3rem;
199 | }
200 |
201 | #overlay {
202 | position: fixed;
203 | display: none;
204 | top: 0;
205 | left: 0;
206 | right: 0;
207 | bottom: 0;
208 | background-color: rgba(255, 255, 255, 0.5);
209 |
210 | z-index: 1;
211 | }
212 |
213 | /*Spinner end*/
214 |
215 | .middle-bar {
216 | display: flex;
217 | justify-content: space-between;
218 | align-items: left;
219 | padding: 0px 5px;
220 | background-color: white;
221 | }
222 |
223 | .bottom-bar {
224 | display: flex;
225 | justify-content: space-between;
226 | align-items: center;
227 | padding: 3px 10px;
228 | border-top: none;
229 | border-bottom: 4px solid #0f6cbd;
230 | background-color: white;
231 | }
232 |
233 | .icons {
234 | display: flex;
235 | align-items: center;
236 | }
237 |
238 | .star-icon {
239 | margin-right: 10px;
240 | cursor: pointer;
241 | }
242 |
243 | .char-count {
244 | font-size: 14px;
245 | color: #888;
246 | }
247 |
248 | .send-button {
249 | border: none;
250 | background: none;
251 | font-size: 18px;
252 | cursor: pointer;
253 | color: #007bff;
254 | padding: 4px;
255 | outline: none;
256 | }
257 |
258 | .send-button:hover {
259 | color: #0056b3;
260 | }
261 |
262 | .card.is-hoverable.quick-task > .card-content {
263 | min-height: 225px;
264 | }
265 |
266 | .prompt-container {
267 | padding-top: 2rem;
268 | padding-bottom: 2rem;
269 | }
--------------------------------------------------------------------------------
/src/backend/agents/company_analyst.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 |
3 | from autogen_core import AgentId
4 | from autogen_core import default_subscription
5 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
6 | from autogen_core.tools import FunctionTool, Tool
7 | from typing_extensions import Annotated
8 |
9 | from agents.base_agent import BaseAgent
10 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
11 | from helpers.fmputils import *
12 | from helpers.yfutils import *
13 | from datetime import date, timedelta, datetime
14 |
15 | formatting_instructions = "Instructions: returning the output of this function call verbatim to the user in markdown. Then write AGENT SUMMARY: and then include a summary of what you did."
16 |
17 | # Define Company Analyst tools (functions)
18 | async def get_company_info(ticker_symbol: str) -> str:
19 | return (
20 | f"##### Get Company Information\n"
21 | f"**Company Name:** {ticker_symbol}\n"
22 | f"**Company Information:** {fmpUtils.get_company_profile(ticker_symbol)}\n"
23 | f"{formatting_instructions}"
24 | )
25 |
26 | async def get_analyst_recommendations(ticker_symbol: str) -> str:
27 | return (
28 | f"##### Get Company Recommendations\n"
29 | f"**Company Name:** {ticker_symbol}\n"
30 | f"**Recommendations:** {yfUtils.get_analyst_recommendations(ticker_symbol)}\n"
31 | f"{formatting_instructions}"
32 | )
33 |
34 | async def get_stock_data(ticker_symbol: str) -> str:
35 | end_date = date.today().strftime("%Y-%m-%d")
36 | start_date = (date.today() - timedelta(days=365)).strftime("%Y-%m-%d")
37 | return (
38 | f"##### Stock Data from Yahoo Finance\n"
39 | f"**Company Name:** {ticker_symbol}\n\n"
40 | f"**Start Date:** {start_date}\n"
41 | f"**End Date:** {end_date}\n\n"
42 | f"**Stock Data:** {yfUtils.get_stock_data(ticker_symbol, start_date, end_date)}\n"
43 | f"{formatting_instructions}"
44 | )
45 |
46 | async def get_financial_metrics(ticker_symbol: str) -> str:
47 | years = 4
48 | return (
49 | f"##### Get Financial Information\n"
50 | f"**Company Name:** {ticker_symbol}\n\n"
51 | f"**Years:** {years}\n\n"
52 | f"**Financial Information:** {fmpUtils.get_financial_metrics(ticker_symbol, years)}\n"
53 | f"{formatting_instructions}"
54 | )
55 |
56 | async def get_company_news(ticker_symbol: str) -> str:
57 | end_date = date.today().strftime("%Y-%m-%d")
58 | start_date = (date.today() - timedelta(days=7)).strftime("%Y-%m-%d")
59 | return (
60 | f"##### Get Company News\n"
61 | f"**Company Name:** {ticker_symbol}\n\n"
62 | #f"**Company News:** {fmpUtils.get_company_news(ticker_symbol, start_date, end_date)}\n"
63 | f"**Company News:** {yfUtils.get_company_news(ticker_symbol, start_date, end_date)}\n"
64 | f"{formatting_instructions}"
65 | )
66 |
67 | async def get_sentiment_analysis(ticker_symbol: str) -> str:
68 | return (
69 | f"##### Get Company Information\n"
70 | f"**Company Name:** {ticker_symbol}\n"
71 | f"{formatting_instructions}"
72 | )
73 |
74 | # async def analyze_predict_company(ticker_symbol: str) -> str:
75 | # return (
76 | # f"##### Analyze and Prediction\n"
77 | # f"**Company Name:** {ticker_symbol}\n\n"
78 | # f"{formatting_instructions}"
79 | # )
80 |
81 | # Create the Company Analyst Tools list
82 | def get_company_analyst_tools() -> List[Tool]:
83 | return [
84 | FunctionTool(
85 | get_company_info,
86 | description="get a company's profile information",
87 | ),
88 | FunctionTool(
89 | get_stock_data,
90 | description="retrieve stock price data for designated ticker symbol",
91 | ),
92 | FunctionTool(
93 | get_financial_metrics,
94 | description="get latest financial basics for a designated company",
95 | ),
96 | FunctionTool(
97 | get_company_news,
98 | description="retrieve market news related to designated company",
99 | ),
100 | FunctionTool(
101 | get_analyst_recommendations,
102 | description="get analyst recommendation for a designated company",
103 | ),
104 | FunctionTool(
105 | get_sentiment_analysis,
106 | description="Analyze the data that you have access to like news and analyst recommendations and provide a sentiment analysis, positive or negative outlook",
107 | ),
108 | # FunctionTool(
109 | # analyze_predict_company,
110 | # description="Analyze and predict the future of a designated company",
111 | # ),
112 | ]
113 |
114 |
115 | @default_subscription
116 | class CompanyAnalystAgent(BaseAgent):
117 | def __init__(
118 | self,
119 | model_client: AzureOpenAIChatCompletionClient,
120 | session_id: str,
121 | user_id: str,
122 | memory: CosmosBufferedChatCompletionContext,
123 | ca_tools: List[Tool],
124 | ca_tool_agent_id: AgentId,
125 | ):
126 | super().__init__(
127 | "CompanyAnalystAgent",
128 | model_client,
129 | session_id,
130 | user_id,
131 | memory,
132 | ca_tools,
133 | ca_tool_agent_id,
134 | system_message="You are an AI Agent. You have knowledge about stock market, company information, company news, analyst recommendation and company's financial data and metrics."
135 | # system_message="As a Company Analyst, one must possess strong analytical and problem-solving abilities, collect necessary financial information and aggregate them based on client's requirement."
136 | # "For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.",
137 | )
138 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/task/task.css:
--------------------------------------------------------------------------------
1 | @import "../app.css";
2 | @import "../assets/bulma-switch.css";
3 |
4 | .task-stats {
5 | min-height: 70px;
6 | }
7 |
8 | .section {
9 | min-height: 100%;
10 | }
11 |
12 | .task-asside {
13 | min-height: 100vh;
14 | max-width: 500px;
15 | }
16 |
17 | .task-asside.is-audit {
18 | max-width: 700px;
19 | }
20 |
21 | .task-asside .task-menu {
22 | margin: 3rem 1rem;
23 | }
24 |
25 | .task-asside .task-menu .menu-label:first-of-type {
26 | margin-top: 137px;
27 | }
28 |
29 | .task-asside .title {
30 | font-size: 1.25rem;
31 | height: 30px;
32 | display: flex;
33 | align-items: center;
34 | }
35 |
36 | .task-details {
37 | width: 100%;
38 | padding: 2rem;
39 | }
40 | .colChatSec {
41 | width: 55%;
42 | }
43 | /*Notification message styles start*/
44 | /* Ensures block-level elements (like
20 |
122 |
21 |
22 |
31 |
32 |
33 |
34 |
37 |
38 |
120 |
121 |
39 |
59 |
60 |
61 |
62 |
40 |
41 |
42 |
43 |
57 |
58 |
63 |
85 |
91 |
92 |
93 |
94 |
95 |
64 |
70 |
65 | Status:
66 |
71 |
75 |
76 |
77 |
78 |
82 |
83 |
84 |
96 |
101 |
106 |
118 |
119 |
107 |
108 | 
109 |
110 |
116 |
117 |
109 |
110 |
116 | ,
, etc.) wrap inside the message */
45 | .notification p,
46 | .notification pre {
47 | margin: 0;
48 | word-wrap: break-word;
49 | white-space: pre-wrap; /* Allow preformatted text to wrap */
50 | }
51 | .message-content {
52 | max-width: 100%;
53 | overflow: hidden;
54 | word-break: break-word;
55 | line-height: 1.4;
56 | }
57 | /* Optional: Add word-breaking for URLs */
58 | .notification a {
59 | word-wrap: break-word;
60 | word-break: break-word;
61 | text-decoration: underline;
62 | }
63 | /*Notification message styles end*/
64 |
65 | .task-progress {
66 | height: 40vh;
67 | overflow-y: auto;
68 | background-color: white;
69 | border-radius: var(--bulma-radius);
70 | }
71 |
72 | @media (min-height: 1200px) {
73 | .task-progress {
74 | height: 50vh;
75 | }
76 | }
77 |
78 | @media (min-height: 1400px) {
79 | .task-progress {
80 | height: 60vh;
81 | }
82 | }
83 |
84 | .task-progress .notification {
85 | padding: 0.5rem 1rem;
86 | display: block;
87 | max-width: 100%;
88 | word-wrap: break-word;
89 | box-sizing: border-box;
90 | overflow-wrap: break-word;
91 | }
92 |
93 | .menu-list .menu-item,
94 | .menu-list a,
95 | .menu-list button {
96 | background-color: transparent;
97 | }
98 |
99 | .menu-list ul.menu-stages {
100 | border-inline-start: 3px solid var(--bulma-border);
101 | padding-inline-start: 0;
102 | }
103 |
104 | .menu-list ul.menu-stages li {
105 | margin-left: calc(-1.4rem - 5px);
106 | }
107 |
108 | .menu-list a.menu-stage {
109 | display: flex;
110 | align-items: center;
111 | position: relative;
112 | padding: 0.5em 0 0.5rem 0.75em;
113 | width: calc(100% + 1.4rem - 5px);
114 | }
115 |
116 | .menu-list a.menu-stage > i {
117 | font-size: 1.4rem;
118 | margin-top: 3px;
119 | border-radius: 50%;
120 | background-color: rgb(247, 249, 251);
121 | padding: 5px;
122 | }
123 |
124 | .menu-list a.menu-stage span {
125 | flex: 1;
126 | word-break: break-word; /*this for stages span alignment*/
127 | }
128 |
129 | .menu-list a.menu-stage.rejected span {
130 | text-decoration: line-through;
131 | opacity: 0.5;
132 | }
133 |
134 | .menu-list a.menu-stage.action_requested span {
135 | font-weight: 500;
136 | }
137 |
138 | .menu-list a.menu-stage div {
139 | display: flex;
140 | align-items: center;
141 | }
142 |
143 | .menu-stage-actions i {
144 | font-size: 1.4rem;
145 | }
146 |
147 | .business-animation {
148 | position: relative;
149 | border-radius: var(--bulma-radius-large);
150 | }
151 |
152 | #taskLoader {
153 | display: flex;
154 | flex-direction: column;
155 | justify-content: center;
156 | align-items: center;
157 | position: absolute;
158 | inset: 0;
159 | color: black;
160 | background-color: rgb(247, 249, 251);
161 | z-index: 1000;
162 | font-weight: 500;
163 | }
164 |
165 | #taskLoader span::before {
166 | content: "Getting task plan...";
167 | animation: taskLoaderAnimation infinite 3s linear;
168 | }
169 |
170 | #taskLoader.is-hidden {
171 | display: none;
172 | }
173 |
174 | @keyframes taskLoaderAnimation {
175 | 0% {
176 | content: "Getting task plan...";
177 | }
178 |
179 | 50% {
180 | content: "Contacting agents...";
181 | }
182 |
183 | 75% {
184 | content: "Loading conversations...";
185 | }
186 | }
187 |
188 | #taskLoader i {
189 | font-size: 3rem;
190 | }
191 |
192 | .task-stage-divider {
193 | text-align: center;
194 | margin: 1rem 0;
195 | font-size: 0.85rem;
196 | font-weight: 500;
197 | border: 1px solid rgb(71, 80, 235);
198 | border-left-width: 0;
199 | border-right-width: 0;
200 | border-bottom-width: 0;
201 | }
202 |
203 | .task-stage-divider legend {
204 | color: rgb(71, 80, 235);
205 | -webkit-padding-start: 1rem;
206 | -webkit-padding-end: 1rem;
207 | background: transparent;
208 | }
209 |
210 | .text-input-container {
211 | position: relative;
212 | border: 1px solid #ccc;
213 | border-radius: 8px;
214 | background-color: white;
215 | }
216 |
217 | textarea {
218 | width: 98%;
219 | padding: 16px 0px 0px 0px;
220 | border: none;
221 | border-radius: 8px 8px 0 0;
222 | font-size: 16px;
223 | line-height: 1.5;
224 | resize: none;
225 | outline: none;
226 | overflow: hidden;
227 | margin: 0 10px;
228 | align-items: center;
229 | background-color: white;
230 | }
231 |
232 | .star-icon {
233 | margin-right: 10px;
234 | cursor: pointer;
235 | }
236 |
237 | .char-count {
238 | font-size: 14px;
239 | color: #888;
240 | }
241 |
242 | .middle-bar {
243 | display: flex;
244 | justify-content: space-between;
245 | align-items: left;
246 | padding: 0px 5px;
247 | /* background-color: white; */
248 | }
249 |
250 | .bottom-bar {
251 | display: flex;
252 | justify-content: space-between;
253 | align-items: center;
254 | padding: 3px 10px;
255 | border-top: none;
256 | border-bottom: 4px solid #0f6cbd;
257 | /* background-color: white; */
258 | }
259 |
260 | .send-button {
261 | border: none;
262 | background: none;
263 | font-size: 18px;
264 | cursor: pointer;
265 | color: #007bff;
266 | padding: 4px;
267 | outline: none;
268 | }
269 |
270 | .send-button:hover {
271 | color: #0056b3;
272 | }
273 |
274 | .menu.task-menu {
275 | position: sticky;
276 | top: 0;
277 | }
--------------------------------------------------------------------------------
/src/frontend/wwwroot/app.css:
--------------------------------------------------------------------------------
1 | @import "https://cdn.jsdelivr.net/npm/bulma@1.0.2/css/bulma.min.css";
2 | @import "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.6.0/css/all.min.css";
3 | @import "assets/theme.css";
4 |
5 | /* App global */
6 |
7 | html,
8 | body {
9 | overflow-x: hidden;
10 | overflow-y: auto;
11 | height: 100%;
12 | }
13 |
14 | body {
15 | position: relative;
16 | background: rgb(247, 249, 251);
17 | min-height: 100vh;
18 | }
19 |
20 | .border-right {
21 | border-right: 1px solid hsl(221, 14%, calc(86% + 0%));
22 | }
23 |
24 | /* App template */
25 |
26 | #app .columns {
27 | min-height: 100vh;
28 | height: 100%;
29 | }
30 | #app .modal,
31 | #app .menu {
32 | overflow: hidden; /* Prevent scrolling within modals and menus */
33 | }
34 | #app .asside {
35 | background: rgba(231, 236, 243, 0.7);
36 | }
37 | ul#tasksStats.menu-list {
38 | min-height: 100px;
39 | }
40 | @media (min-width: 1800px) {
41 | #app .asside {
42 | max-width: 400px;
43 | }
44 | }
45 |
46 | #app .menu-logo {
47 | font-size: 1.25rem;
48 | font-weight: 700;
49 | cursor: pointer;
50 | }
51 |
52 | #app .menu-logo img {
53 | width: 30px;
54 | }
55 |
56 | #app .asside .menu-list a {
57 | background-color: transparent;
58 | }
59 |
60 | #app .asside .menu-list a.is-active {
61 | background-color: rgb(71, 80, 235);
62 | }
63 |
64 | #app .asside .menu-list a.is-active i {
65 | color: white !important;
66 | }
67 |
68 | #app .asside .menu-list a.is-active:hover {
69 | background-color: rgb(71, 80, 235);
70 | }
71 |
72 | #app .asside .menu-list a.menu-task {
73 | display: flex;
74 | align-items: center;
75 | }
76 |
77 | #app .asside .menu-list a.menu-task span {
78 | flex: 1;
79 | }
80 |
81 | #app .asside .menu-list a:hover {
82 | background-color: rgba(0, 0, 0, 0.1);
83 | }
84 |
85 | #app .iframe {
86 | width: 100%;
87 | background-color: transparent;
88 | }
89 |
90 | #app .context-switch {
91 | position: fixed;
92 | bottom: 50px;
93 | right: calc(50% - 220px);
94 | z-index: 3;
95 | }
96 |
97 | .is-avatar.is-rounded {
98 | border-radius: var(--bulma-radius-rounded);
99 | }
100 |
101 | .is-avatar.is-agent {
102 | display: flex;
103 | /* background-color: rgba(231, 236, 243, 0.7); */
104 | background-color: rgba(70, 79, 235, 0.25);
105 | }
106 |
107 | .is-avatar.is-agent img {
108 | width: 75%;
109 | height: 75%;
110 | margin: 13%;
111 | }
112 |
113 | @keyframes moveImage {
114 | 0% {
115 | transform: rotate(0deg);
116 | }
117 |
118 | 50% {
119 | transform: rotate(-3deg);
120 | }
121 |
122 | 100% {
123 | transform: rotate(3deg);
124 | }
125 | }
126 |
127 | .is-avatar.is-agent img.manager {
128 | background-color: rgba(220, 56, 72, 0.35);
129 | box-shadow: 0 0 0 4px rgba(220, 56, 72, 0.35);
130 | animation: moveImage 0.3s infinite alternate;
131 | }
132 |
133 | .is-avatar.is-agent img.hr_agent {
134 | background-color: rgba(0, 209, 178, 0.35);
135 | box-shadow: 0 0 0 4px rgba(0, 209, 178, 0.35);
136 | animation: moveImage 0.5s infinite alternate;
137 | }
138 |
139 | .is-avatar.is-agent img.procurement_agent {
140 | background-color: rgba(255, 183, 15, 0.35);
141 | box-shadow: 0 0 0 4px rgba(255, 183, 15, 0.35);
142 | animation: moveImage 0.1s infinite alternate;
143 | }
144 |
145 | .is-avatar.is-agent img.tech_agent {
146 | background-color: rgba(178, 222, 39, 0.35);
147 | box-shadow: 0 0 0 4px rgba(178, 222, 39, 0.35);
148 | animation: moveImage 0.7s infinite alternate;
149 | }
150 |
151 | .is-avatar.is-agent img.unknown {
152 | background-color: rgba(39, 57, 222, 0.35);
153 | box-shadow: 0 0 0 4px rgba(39, 57, 222, 0.35);
154 | animation: moveImage 0.7s infinite alternate;
155 | }
156 |
157 | .is-avatar.has-status::after {
158 | content: "";
159 | position: absolute;
160 | bottom: 0;
161 | right: 0;
162 | width: 30%;
163 | height: 30%;
164 | border-radius: 50%;
165 | background-color: rgb(255, 255, 255);
166 | border: 2px solid rgb(255, 255, 255);
167 | }
168 |
169 | .is-avatar.has-status.has-status-active::after {
170 | background-color: hsl(
171 | var(--bulma-success-h),
172 | var(--bulma-success-s),
173 | var(--bulma-success-l)
174 | );
175 | }
176 |
177 | .is-avatar.has-status.has-status-busy::after {
178 | background-color: hsl(
179 | var(--bulma-danger-h),
180 | var(--bulma-danger-s),
181 | var(--bulma-danger-l)
182 | );
183 | }
184 |
185 | .is-avatar.has-status.has-status-paused::after {
186 | background-color: hsl(
187 | var(--bulma-dark-h),
188 | var(--bulma-dark-s),
189 | var(--bulma-dark-l)
190 | );
191 | }
192 |
193 | .button.is-greyed-out {
194 | background-color: #e0e0e0;
195 | color: lightgrey;
196 | cursor: not-allowed;
197 | }
198 |
199 | .button.is-selected {
200 | background-color: #d3d3d3;
201 | color: #000;
202 | }
203 |
204 | .notyf__toast {
205 | max-width: 100% !important;
206 | border-radius: var(--bulma-control-radius) !important;
207 | }
208 |
209 | .notyf__wrapper {
210 | padding: 0.75rem 0.5rem !important;
211 | }
212 | /* Menu list scroll style start*/
213 | #app .asside .menu-list {
214 | max-height: 400px;
215 | overflow-y: scroll;
216 | padding-right: 2px;
217 | transition: all 0.3s ease;
218 | box-sizing: border-box;
219 | }
220 | /* Hide the scrollbar initially (before hover) */
221 | #app .asside .menu-list::-webkit-scrollbar {
222 | width: 8px;
223 | opacity: 0;
224 | visibility: hidden;
225 | transition: opacity 0.3s ease, visibility 0s 0.3s;
226 | }
227 | /* Style the scrollbar thumb (the draggable part) */
228 | #app .asside .menu-list::-webkit-scrollbar-thumb {
229 | border-radius: 10px;
230 | transition: background-color 0.3s ease;
231 | }
232 | /* Show the scrollbar and thumb when hovering */
233 | #app .asside .menu-list:hover::-webkit-scrollbar {
234 | opacity: 1;
235 | visibility: visible;
236 | transition: opacity 0.3s ease, visibility 0s;
237 | }
238 | /* Style the thumb when hovering */
239 | #app .asside .menu-list:hover::-webkit-scrollbar-thumb {
240 | background-color: rgba(0, 0, 0, 0.2);
241 | }
242 | /* Menu list scroll style end*/
243 |
--------------------------------------------------------------------------------
/src/backend/agents/base_agent.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Any, List, Mapping
3 |
4 | from autogen_core import AgentId, MessageContext
5 | from autogen_core import RoutedAgent, message_handler
6 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
7 | from autogen_core.models import (AssistantMessage, LLMMessage, SystemMessage,
8 | UserMessage)
9 | from autogen_core.tool_agent import tool_agent_caller_loop
10 | from autogen_core.tools import Tool
11 |
12 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
13 | from models.messages import (ActionRequest, ActionResponse,
14 | AgentMessage, Step, StepStatus)
15 | from event_utils import track_event_if_configured
16 |
17 | class BaseAgent(RoutedAgent):
18 | def __init__(
19 | self,
20 | agent_name: str,
21 | model_client: AzureOpenAIChatCompletionClient,
22 | session_id: str,
23 | user_id: str,
24 | model_context: CosmosBufferedChatCompletionContext,
25 | tools: List[Tool],
26 | tool_agent_id: AgentId,
27 | system_message: str,
28 | ):
29 | super().__init__(agent_name)
30 | self._agent_name = agent_name
31 | self._model_client = model_client
32 | self._session_id = session_id
33 | self._user_id = user_id
34 | self._model_context = model_context
35 | self._tools = tools
36 | self._tool_schema = [tool.schema for tool in tools]
37 | self._tool_agent_id = tool_agent_id
38 | self._chat_history: List[LLMMessage] = [SystemMessage(content=system_message)]
39 |
40 | @message_handler
41 | async def handle_action_request(
42 | self, message: ActionRequest, ctx: MessageContext
43 | ) -> ActionResponse:
44 | step: Step = await self._model_context.get_step(
45 | message.step_id, message.session_id
46 | )
47 | # TODO: Agent verbosity
48 | # await self._model_context.add_item(
49 | # AgentMessage(
50 | # session_id=message.session_id,
51 | # plan_id=message.plan_id,
52 | # content=f"{self._agent_name} received action request: {message.action}",
53 | # source=self._agent_name,
54 | # step_id=message.step_id,
55 | # )
56 | # )
57 | if not step:
58 | return ActionResponse(
59 | step_id=message.step_id,
60 | status=StepStatus.failed,
61 | message="Step not found in memory.",
62 | )
63 | # TODO - here we use the action message as the source of the action, rather than step.action, as we have added a temporary conversation history to the agent, as a mechanism to give it visibility of the replies of other agents. The logic/approach needs to be thought through further to make it more consistent.
64 | self._chat_history.extend(
65 | [
66 | AssistantMessage(content=message.action, source="GroupChatManager"),
67 | UserMessage(
68 | content=f"{step.human_feedback}. Now make the function call",
69 | source="HumanAgent",
70 | ),
71 | ]
72 | )
73 | try:
74 | messages: List[LLMMessage] = await tool_agent_caller_loop(
75 | caller=self,
76 | tool_agent_id=self._tool_agent_id,
77 | model_client=self._model_client,
78 | input_messages=self._chat_history,
79 | tool_schema=self._tools,
80 | cancellation_token=ctx.cancellation_token,
81 | )
82 | logging.info("*" * 12)
83 | logging.info(f"LLM call completed: {messages}")
84 | final_message = messages[-1]
85 | assert isinstance(final_message.content, str)
86 | result = final_message.content
87 | await self._model_context.add_item(
88 | AgentMessage(
89 | session_id=message.session_id,
90 | user_id=self._user_id,
91 | plan_id=message.plan_id,
92 | content=f"{result}",
93 | source=self._agent_name,
94 | step_id=message.step_id,
95 | )
96 | )
97 |
98 | track_event_if_configured(
99 | "Base agent - Added into the cosmos",
100 | {
101 | "session_id": message.session_id,
102 | "user_id": self._user_id,
103 | "plan_id": message.plan_id,
104 | "content": f"{result}",
105 | "source": self._agent_name,
106 | "step_id": message.step_id,
107 | },
108 | )
109 | except Exception as e:
110 | print(f"Error during LLM call: {e}")
111 | return
112 | print(f"Task completed: {result}")
113 |
114 | step.status = StepStatus.completed
115 | step.agent_reply = result
116 | await self._model_context.update_step(step)
117 |
118 | track_event_if_configured(
119 | "Base agent - Updated step and updated into the cosmos",
120 | {
121 | "status": StepStatus.completed,
122 | "session_id": message.session_id,
123 | "agent_reply": f"{result}",
124 | "user_id": self._user_id,
125 | "plan_id": message.plan_id,
126 | "content": f"{result}",
127 | "source": self._agent_name,
128 | "step_id": message.step_id,
129 | },
130 | )
131 |
132 | action_response = ActionResponse(
133 | step_id=step.id,
134 | plan_id=step.plan_id,
135 | session_id=message.session_id,
136 | result=result,
137 | status=StepStatus.completed,
138 | )
139 |
140 | group_chat_manager_id = AgentId("group_chat_manager", self._session_id)
141 | await self.publish_message(action_response, group_chat_manager_id)
142 | # TODO: Agent verbosity
143 | # await self._model_context.add_item(
144 | # AgentMessage(
145 | # session_id=message.session_id,
146 | # plan_id=message.plan_id,
147 | # content=f"{self._agent_name} sending update to GroupChatManager",
148 | # source=self._agent_name,
149 | # step_id=message.step_id,
150 | # )
151 | # )
152 | return action_response
153 |
154 | def save_state(self) -> Mapping[str, Any]:
155 | print("Saving state:")
156 | return {"memory": self._model_context.save_state()}
157 |
158 | def load_state(self, state: Mapping[str, Any]) -> None:
159 | self._model_context.load_state(state["memory"])
160 |
--------------------------------------------------------------------------------
/src/backend/agents/earningcalls_analyst.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 |
3 | from autogen_core import AgentId
4 | from autogen_core import default_subscription
5 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
6 | from autogen_core.tools import FunctionTool, Tool
7 | from typing_extensions import Annotated
8 |
9 | from agents.base_agent import BaseAgent
10 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
11 | from helpers.fmputils import *
12 | from helpers.yfutils import *
13 | from datetime import date, timedelta, datetime
14 | from helpers.summarizeutils import summarize, summarizeTopic
15 | from helpers.dcfutils import DcfUtils
16 |
17 | formatting_instructions = "Instructions: returning the output of this function call verbatim to the user in markdown."
18 | latestEarnings = None
19 |
20 | # Define HR tools (functions)
21 | async def get_earning_calls_transcript(ticker_symbol: str, year:str) -> str:
22 | global latestEarnings
23 | print("Calling get_earning_calls_transcript")
24 | if year is None or year == "latest":
25 | year = datetime.now().year
26 | if datetime.now().month < 3:
27 | year = int(year) - 1
28 |
29 | if latestEarnings is None or len(latestEarnings) == 0:
30 | #latestEarnings = fmpUtils.get_earning_calls(ticker_symbol, year)
31 | latestEarnings = DcfUtils.get_earning_calls(ticker_symbol)
32 | return (
33 | f"##### Get Earning Calls\n"
34 | f"{formatting_instructions}"
35 | )
36 |
37 | async def summarize_transcripts(ticker_symbol:str, year:str) -> str:
38 | global latestEarnings
39 | if latestEarnings is None or len(latestEarnings) == 0:
40 | #latestEarnings = fmpUtils.get_earning_calls(ticker_symbol, year)
41 | latestEarnings = DcfUtils.get_earning_calls(ticker_symbol)
42 | print("*"*35)
43 | print("Calling summarize_transcripts")
44 | summarized = summarize(latestEarnings)
45 | print("*"*35)
46 | return (
47 | f"##### Summarized transcripts\n"
48 | f"**Company Name:** {ticker_symbol}\n"
49 | f"**Summary:** {summarized}\n"
50 | f"{formatting_instructions}"
51 | )
52 |
53 | async def management_positive_outlook(ticker_symbol: str, year:str) -> str:
54 | global latestEarnings
55 | if latestEarnings is None or len(latestEarnings) == 0:
56 | #latestEarnings = fmpUtils.get_earning_calls(ticker_symbol, year)
57 | latestEarnings = DcfUtils.get_earning_calls(ticker_symbol)
58 | print("*"*35)
59 | print("Calling management_positive_outlook")
60 | positiveOutlook = summarizeTopic(latestEarnings, 'Management Positive Outlook')
61 | print("*"*35)
62 | return (
63 | f"##### Management Positive Outlook\n"
64 | f"**Company Name:** {ticker_symbol}\n"
65 | f"**Topic Summary:** {positiveOutlook}\n"
66 | f"{formatting_instructions}"
67 | )
68 |
69 | async def management_negative_outlook(ticker_symbol: str, year:str) -> str:
70 | global latestEarnings
71 | if latestEarnings is None or len(latestEarnings) == 0:
72 | #latestEarnings = fmpUtils.get_earning_calls(ticker_symbol, year)
73 | latestEarnings = DcfUtils.get_earning_calls(ticker_symbol)
74 | print("*"*35)
75 | print("Calling management_negative_outlook")
76 | negativeOutlook = summarizeTopic(latestEarnings, 'Management Negative Outlook')
77 | print("*"*35)
78 | years = 4
79 | return (
80 | f"##### Management Negative Outlook\n"
81 | f"**Company Name:** {ticker_symbol}\n"
82 | f"**Topic Summary:** {negativeOutlook}\n"
83 | f"{formatting_instructions}"
84 | )
85 |
86 | async def future_growth_opportunity(ticker_symbol: str, year:str) -> str:
87 | global latestEarnings
88 | if latestEarnings is None or len(latestEarnings) == 0:
89 | #latestEarnings = fmpUtils.get_earning_calls(ticker_symbol, year)
90 | latestEarnings = DcfUtils.get_earning_calls(ticker_symbol)
91 | print("*"*35)
92 | print("Calling management_negative_outlook")
93 | futureGrowth = summarizeTopic(latestEarnings, 'Future Growth Opportunities')
94 | print("*"*35)
95 | return (
96 | f"##### Future Growth and Opportunities\n"
97 | f"**Company Name:** {ticker_symbol}\n\n"
98 | f"**Topic Summary:** {futureGrowth}\n"
99 | f"{formatting_instructions}"
100 | )
101 |
102 | # async def analyze_predict_transcript(ticker_symbol: str) -> str:
103 | # return (
104 | # f"##### Transcription Analyze and Prediction\n"
105 | # f"**Company Name:** {ticker_symbol}\n\n"
106 | # f"{formatting_instructions}"
107 | # )
108 |
109 | # Create the Company Analyst Tools list
110 | def get_earning_calls_analyst_tools() -> List[Tool]:
111 | return [
112 | FunctionTool(
113 | get_earning_calls_transcript,
114 | description="get a earning call's transcript for a company",
115 | ),
116 | FunctionTool(
117 | summarize_transcripts,
118 | description="summarize the earning call's transcript for a company",
119 | ),
120 | FunctionTool(
121 | management_positive_outlook,
122 | description="From the extracted earning call's transcript, identify the management's positive outlook for a company",
123 | ),
124 | FunctionTool(
125 | management_negative_outlook,
126 | description="From the extracted earning call's transcript, identify the management's negative outlook for a company",
127 | ),
128 | FunctionTool(
129 | future_growth_opportunity,
130 | description="From the extracted earning call's transcript, identify the future growth and opportunities for a company",
131 | ),
132 | # FunctionTool(
133 | # analyze_predict_transcript,
134 | # description="Analyze and predict the future of a designated company based on the information from the earning call's transcript",
135 | # ),
136 | ]
137 |
138 |
139 | @default_subscription
140 | class EarningCallsAnalystAgent(BaseAgent):
141 | def __init__(
142 | self,
143 | model_client: AzureOpenAIChatCompletionClient,
144 | session_id: str,
145 | user_id: str,
146 | memory: CosmosBufferedChatCompletionContext,
147 | earning_calls_analyst_tools: List[Tool],
148 | earning_calls_analyst_tool_agent_id: AgentId,
149 | ):
150 | super().__init__(
151 | "EarningCallsAnalystAgent",
152 | model_client,
153 | session_id,
154 | user_id,
155 | memory,
156 | earning_calls_analyst_tools,
157 | earning_calls_analyst_tool_agent_id,
158 | system_message="You are an AI Agent. You have knowledge about the management positive and negative outlook, future growths and opportunities based on the earning call transcripts."
159 | )
160 |
--------------------------------------------------------------------------------
/src/backend/helpers/dcfutils.py:
--------------------------------------------------------------------------------
1 | import os
2 | import requests
3 | import numpy as np
4 | import pandas as pd
5 | from datetime import datetime, timedelta
6 | import random
7 | from helpers.dutils import decorate_all_methods
8 | from helpers.summarizeutils import get_next_weekday
9 | import re
10 | from tenacity import RetryError
11 | from tenacity import retry, stop_after_attempt, wait_random_exponential
12 | from langchain.schema import Document
13 | import json
14 | from typing import List
15 | import ast
16 |
17 | # from finrobot.utils import decorate_all_methods, get_next_weekday
18 | from functools import wraps
19 | from typing import Annotated, List
20 |
21 | def init_dcf_api(func):
22 | @wraps(func)
23 | def wrapper(*args, **kwargs):
24 | global dcf_api_key
25 | if os.environ.get("DCF_API_KEY") is None:
26 | print("Please set the environment variable DCF_API_KEY to use the DCF API.")
27 | return None
28 | else:
29 | dcf_api_key = os.environ["DCF_API_KEY"]
30 | print("DCF api key found successfully.")
31 | return func(*args, **kwargs)
32 |
33 | return wrapper
34 |
35 | @decorate_all_methods(init_dcf_api)
36 | class DcfUtils:
37 |
38 | def correct_date(yr, dt):
39 | """Some transcripts have incorrect date, correcting it
40 |
41 | Args:
42 | yr (int): actual
43 | dt (datetime): given date
44 |
45 | Returns:
46 | datetime: corrected date
47 | """
48 | dt = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
49 | if dt.year != yr:
50 | dt = dt.replace(year=yr)
51 | return dt.strftime("%Y-%m-%d %H:%M:%S")
52 |
53 | def extract_speakers(cont: str) -> List[str]:
54 | """Extract the list of speakers
55 |
56 | Args:
57 | cont (str): transcript content
58 |
59 | Returns:
60 | List[str]: list of speakers
61 | """
62 | pattern = re.compile(r"\n(.*?):")
63 | matches = pattern.findall(cont)
64 |
65 | return list(set(matches))
66 |
67 | def clean_speakers(speaker):
68 | speaker = re.sub("\n", "", speaker)
69 | speaker = re.sub(":", "", speaker)
70 | return speaker
71 |
72 | def get_earnings_transcript(quarter: str, ticker: str, year: int):
73 | """Get the earnings transcripts
74 |
75 | Args:
76 | quarter (str)
77 | ticker (str)
78 | year (int)
79 | """
80 | response = requests.get(
81 | f"https://discountingcashflows.com/api/transcript/?ticker={ticker}&quarter={quarter}&year={year}&key={dcf_api_key}"
82 | )
83 |
84 | resp_text = json.loads(response.text)
85 | # speakers_list = extract_speakers(resp_text[0]["content"])
86 | corrected_date = DcfUtils.correct_date(resp_text[0]["year"], resp_text[0]["date"])
87 | resp_text[0]["date"] = corrected_date
88 | return resp_text[0]
89 |
90 | def get_earnings_all_quarters_data(quarter: str, ticker: str, year: int):
91 | docs = []
92 | resp_dict = DcfUtils.get_earnings_transcript(quarter, ticker, year)
93 |
94 | content = resp_dict["content"]
95 | pattern = re.compile(r"\n(.*?):")
96 | matches = pattern.finditer(content)
97 |
98 | speakers_list = []
99 | ranges = []
100 | for match_ in matches:
101 | # print(match.span())
102 | span_range = match_.span()
103 | # first_idx = span_range[0]
104 | # last_idx = span_range[1]
105 | ranges.append(span_range)
106 | speakers_list.append(match_.group())
107 | speakers_list = [DcfUtils.clean_speakers(sl) for sl in speakers_list]
108 |
109 | for idx, speaker in enumerate(speakers_list[:-1]):
110 | start_range = ranges[idx][1]
111 | end_range = ranges[idx + 1][0]
112 | speaker_text = content[start_range + 1 : end_range]
113 |
114 | docs.append(
115 | Document(
116 | page_content=speaker_text,
117 | metadata={"speaker": speaker, "quarter": quarter},
118 | )
119 | )
120 |
121 | docs.append(
122 | Document(
123 | page_content=content[ranges[-1][1] :],
124 | metadata={"speaker": speakers_list[-1], "quarter": quarter},
125 | )
126 | )
127 | return docs, speakers_list
128 |
129 | def get_earning_calls(ticker: str) -> str:
130 |
131 | url = f"https://discountingcashflows.com/api/transcript/list/?ticker={ticker}&key={dcf_api_key}"
132 |
133 | response = requests.get(url)
134 |
135 | if response.status_code == 200:
136 | data = ast.literal_eval(response.text)
137 | quarter, year = data[0][0], data[0][1]
138 |
139 | resp_dict = DcfUtils.get_earnings_transcript("Q" + str(quarter), ticker, year)
140 |
141 | transcripts = resp_dict["content"]
142 | return transcripts
143 | else:
144 | return f"Failed to retrieve data: {response.status_code}"
145 |
146 | def get_earnings_all_docs(ticker: str, year: int):
147 | earnings_docs = []
148 | earnings_call_quarter_vals = []
149 | print("Earnings Call Q1")
150 | try:
151 | docs, speakers_list_1 = DcfUtils.get_earnings_all_quarters_data("Q1", ticker, year)
152 | earnings_call_quarter_vals.append("Q1")
153 | earnings_docs.extend(docs)
154 | except RetryError:
155 | print(f"Don't have the data for Q1")
156 | speakers_list_1 = []
157 |
158 | print("Earnings Call Q2")
159 | try:
160 | docs, speakers_list_2 = DcfUtils.get_earnings_all_quarters_data("Q2", ticker, year)
161 | earnings_call_quarter_vals.append("Q2")
162 | earnings_docs.extend(docs)
163 | except RetryError:
164 | print(f"Don't have the data for Q2")
165 | speakers_list_2 = []
166 | print("Earnings Call Q3")
167 | try:
168 | docs, speakers_list_3 = DcfUtils.get_earnings_all_quarters_data("Q3", ticker, year)
169 | earnings_call_quarter_vals.append("Q3")
170 | earnings_docs.extend(docs)
171 | except RetryError:
172 | print(f"Don't have the data for Q3")
173 | speakers_list_3 = []
174 | print("Earnings Call Q4")
175 | try:
176 | docs, speakers_list_4 = DcfUtils.get_earnings_all_quarters_data("Q4", ticker, year)
177 | earnings_call_quarter_vals.append("Q4")
178 | earnings_docs.extend(docs)
179 | except RetryError:
180 | print(f"Don't have the data for Q4")
181 | speakers_list_4 = []
182 | return (
183 | earnings_docs,
184 | earnings_call_quarter_vals,
185 | speakers_list_1,
186 | speakers_list_2,
187 | speakers_list_3,
188 | speakers_list_4,
189 | )
190 |
--------------------------------------------------------------------------------
/src/frontend/wwwroot/home/home.js:
--------------------------------------------------------------------------------
1 | (() => {
2 | const notyf = new Notyf({
3 | position: { x: "right", y: "top" },
4 | ripple: false,
5 | duration: 3000,
6 | });
7 | const apiEndpoint = sessionStorage.getItem("apiEndpoint");
8 | const newTaskPrompt = document.getElementById("newTaskPrompt");
9 | const startTaskButton = document.getElementById("startTaskButton");
10 | const startTaskButtonContainer = document.querySelector(".send-button");
11 | const startTaskButtonImg = startTaskButtonContainer
12 | ? startTaskButtonContainer.querySelector("img")
13 | : null;
14 |
15 | newTaskPrompt.focus();
16 |
17 | // Create spinner element
18 | const createSpinner = () => {
19 | if (!document.getElementById("spinnerContainer")) {
20 | const spinnerContainer = document.createElement("div");
21 | spinnerContainer.id = "spinnerContainer";
22 | spinnerContainer.innerHTML = `
23 |
24 |
25 |
26 |
27 |
28 | `;
29 | document.body.appendChild(spinnerContainer);
30 | }
31 | };
32 |
33 | // Function to create and add the overlay
34 | const createOverlay = () => {
35 | let overlay = document.getElementById("overlay");
36 | if (!overlay) {
37 | overlay = document.createElement("div");
38 | overlay.id = "overlay";
39 | document.body.appendChild(overlay);
40 | }
41 | };
42 |
43 | const showOverlay = () => {
44 | const overlay = document.getElementById("overlay");
45 | if (overlay) {
46 | overlay.style.display = "block";
47 | }
48 | createSpinner();
49 | };
50 |
51 | const hideOverlay = () => {
52 | const overlay = document.getElementById("overlay");
53 | if (overlay) {
54 | overlay.style.display = "none";
55 | }
56 | removeSpinner();
57 | };
58 |
59 | // Remove spinner element
60 | const removeSpinner = () => {
61 | const spinnerContainer = document.getElementById("spinnerContainer");
62 | if (spinnerContainer) {
63 | spinnerContainer.remove();
64 | }
65 | };
66 |
67 | // Function to update button image based on textarea content
68 | const updateButtonImage = () => {
69 | if (startTaskButtonImg) {
70 | if (newTaskPrompt.value.trim() === "") {
71 | startTaskButtonImg.src = "../assets/images/air-button.svg";
72 | startTaskButton.disabled = true;
73 | } else {
74 | startTaskButtonImg.src = "/assets/Send.svg";
75 | startTaskButtonImg.style.width = "16px";
76 | startTaskButtonImg.style.height = "16px";
77 | startTaskButton.disabled = false;
78 | }
79 | }
80 | };
81 |
82 | const startTask = () => {
83 | startTaskButton.addEventListener("click", (event) => {
84 | if (startTaskButton.disabled) {
85 | return;
86 | }
87 | const sessionId =
88 | "sid_" + new Date().getTime() + "_" + Math.floor(Math.random() * 10000);
89 |
90 | newTaskPrompt.disabled = true;
91 | startTaskButton.disabled = true;
92 | startTaskButton.classList.add("is-loading");
93 | createOverlay();
94 | showOverlay();
95 | window.headers.then((headers) => {
96 | fetch(apiEndpoint + "/input_task", {
97 | method: "POST",
98 | headers: headers,
99 | body: JSON.stringify({
100 | session_id: sessionId,
101 | description: newTaskPrompt.value,
102 | }),
103 | })
104 | .then((response) => response.json())
105 | .then((data) => {
106 | if (data.status == "Plan not created") {
107 | notyf.error("Unable to create plan for this task.");
108 | newTaskPrompt.disabled = false;
109 | startTaskButton.disabled = false;
110 | return;
111 | }
112 |
113 | console.log("startTaskButton", data);
114 |
115 | newTaskPrompt.disabled = false;
116 | startTaskButton.disabled = false;
117 | startTaskButton.classList.remove("is-loading");
118 |
119 | window.parent.postMessage(
120 | {
121 | action: "taskStarted",
122 | session_id: data.session_id,
123 | task_id: data.plan_id,
124 | task_name: newTaskPrompt.value,
125 | },
126 | "*"
127 | );
128 |
129 | newTaskPrompt.value = "";
130 |
131 | // Reset character count to 0
132 | const charCount = document.getElementById("charCount");
133 | if (charCount) {
134 | charCount.textContent = "0";
135 | }
136 | updateButtonImage();
137 | notyf.success("Task created successfully. AI agents are on it!");
138 |
139 | // Remove spinner and hide overlay
140 | removeSpinner();
141 | hideOverlay();
142 | })
143 | .catch((error) => {
144 | console.error("Error:", error);
145 | newTaskPrompt.disabled = false;
146 | startTaskButton.disabled = false;
147 | startTaskButton.classList.remove("is-loading");
148 |
149 | // Remove spinner and hide overlay
150 | removeSpinner();
151 | hideOverlay();
152 | });
153 | });
154 | });
155 | };
156 |
157 | const quickTasks = () => {
158 | document.querySelectorAll(".quick-task").forEach((task) => {
159 | task.addEventListener("click", (event) => {
160 | const quickTaskPrompt =
161 | task.querySelector(".quick-task-prompt").innerHTML;
162 | newTaskPrompt.value = quickTaskPrompt.trim().replace(/\s+/g, " ");
163 | const charCount = document.getElementById("charCount");
164 | // Update character count
165 | charCount.textContent = newTaskPrompt.value.length;
166 | updateButtonImage();
167 | newTaskPrompt.focus();
168 | });
169 | });
170 | };
171 | const handleTextAreaTyping = () => {
172 | const newTaskPrompt = document.getElementById("newTaskPrompt");
173 | newTaskPrompt.addEventListener("input", () => {
174 | // const textInput = document.getElementById("newTaskPrompt");
175 | const charCount = document.getElementById("charCount");
176 |
177 | // Update character count
178 | charCount.textContent = newTaskPrompt.value.length;
179 |
180 | // Dynamically adjust height
181 | newTaskPrompt.style.height = "auto";
182 | newTaskPrompt.style.height = newTaskPrompt.scrollHeight + "px";
183 |
184 | updateButtonImage();
185 | });
186 |
187 | newTaskPrompt.addEventListener("keydown", (event) => {
188 | const textValue = newTaskPrompt.value.trim();
189 | // If Enter is pressed without Shift, and the textarea is empty, prevent default behavior
190 | if (event.key === "Enter" && !event.shiftKey) {
191 | if (textValue === "") {
192 | event.preventDefault(); // Disable Enter when textarea is empty
193 | } else {
194 | // If there's content in the textarea, allow Enter to trigger the task button click
195 | startTaskButton.click();
196 | }
197 | } else if (event.key === "Enter" && event.shiftKey) {
198 | return;
199 | }
200 | });
201 | };
202 |
203 | updateButtonImage();
204 | startTask();
205 | quickTasks();
206 | handleTextAreaTyping();
207 | })();
208 |
--------------------------------------------------------------------------------
/src/backend/agents/forecaster.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 |
3 | from autogen_core import AgentId
4 | from autogen_core import default_subscription
5 | from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
6 | from autogen_core.tools import FunctionTool, Tool
7 |
8 | from agents.base_agent import BaseAgent
9 | from context.cosmos_memory import CosmosBufferedChatCompletionContext
10 | from helpers.fmputils import *
11 | from helpers.yfutils import *
12 | from helpers.analyzer import *
13 | from typing import List, Dict, Any
14 | import json
15 |
16 | formatting_instructions = "Instructions: returning the output of this function call verbatim to the user in markdown."
17 |
18 | async def analyze_and_predict(analysis_result: Dict[str, Any]) -> str:
19 | """
20 | Takes the JSON output from ExtendedCombinedAnalysisAgent (technical indicators,
21 | candlestick patterns, fundamentals, news sentiment, final decision),
22 | and uses an LLM to produce a structured forecast with:
23 | 1) A multi-section format (Introduction, Technical, Fundamental, etc.)
24 | 2) An explanation of probability/score as confidence (e.g., 70% => "moderately strong")
25 | 3) A final recommendation
26 | 4) Legal disclaimers
27 |
28 | Returns a markdown or text response with these structured sections.
29 | """
30 | # Convert analysis_result into a JSON string
31 | analysis_json_str = json.dumps(analysis_result, indent=2)
32 |
33 | # Extract the final probability from the JSON for prompt usage
34 | final_decision = analysis_result.get("final_decision", {})
35 | probability_value = final_decision.get("probability", None)
36 | rating_value = final_decision.get("rating", "hold")
37 |
38 | # We can provide instructions to interpret the confidence level:
39 | # e.g., 0.0-0.33 => "low confidence", 0.33-0.66 => "moderate confidence", 0.66-1.0 => "high confidence"
40 | # We'll do a bit of logic to embed in the prompt. Alternatively, let the LLM do it entirely.
41 | confidence_descriptor = "moderate"
42 | if probability_value is not None:
43 | if probability_value <= 0.33:
44 | confidence_descriptor = "low"
45 | elif probability_value >= 0.66:
46 | confidence_descriptor = "high"
47 | else:
48 | confidence_descriptor = "moderate"
49 |
50 | # Construct a detailed prompt with strict output structure
51 | prompt = f"""
52 | You are a specialized financial analysis LLM. You have received a JSON structure that
53 | represents an extended analysis of a stock, including:
54 | - Technical signals (RSI, MACD, Bollinger, EMA crossover, Stochastics, ADX)
55 | - Candlestick pattern detections (TA-Lib)
56 | - Basic fundamentals (P/E ratios, etc.)
57 | - News sentiment
58 | - A final numeric probability (score) and rating (Buy/Sell/Hold).
59 |
60 | The JSON data is:
61 |
62 | ```
63 | {analysis_json_str}
64 | ```
65 |
66 | **Please return your answer in the following sections:**
67 |
68 | 1) **Introduction**
69 | - Briefly introduce the analysis.
70 |
71 | 2) **Technical Overview**
72 | - Summarize the key technical indicators and any candlestick patterns.
73 | - Explain whether they are bullish, bearish, or neutral.
74 |
75 | 3) **Fundamental Overview**
76 | - Mention any notable fundamental data (like forwardPE, trailingPE, etc.)
77 | and how it influences the outlook.
78 |
79 | 4) **News & Sentiment**
80 | - Highlight the sentiment score (range: -1.0 to +1.0).
81 | Explain if it's a tailwind (positive) or headwind (negative).
82 |
83 | 5) **Probability & Confidence**
84 | - The system’s final probability is **{probability_value}** (range: 0.0 to 1.0).
85 | - Interpret it as **{confidence_descriptor}** confidence
86 | (e.g., <=0.33 => "low", 0.33-0.66 => "moderate", >=0.66 => "high").
87 | - Elaborate how confident or uncertain this rating might be based on
88 | conflicting signals, volatility, etc.
89 |
90 | 6) **Final Recommendation**
91 | - Based on the system’s final rating: **{rating_value}**.
92 | - Explain briefly why you agree or disagree, or how you interpret it.
93 |
94 | 7) **Disclaimers**
95 | - Include disclaimers such as "Past performance is not indicative of future results."
96 | - Remind the user that this is not guaranteed investment advice.
97 | - Encourage further research before making any decisions.
98 |
99 | Please format your response in **Markdown**, with headings for each section
100 | and bullet points where appropriate.
101 | """
102 |
103 | return prompt
104 | # Now we call the LLM with this prompt. We'll mock the response for this example.
105 | # In real usage, you'd do something like:
106 | # response = await model_client.get_chat_completion(
107 | # system_message="You are a financial analysis LLM.",
108 | # user_message=prompt,
109 | # temperature=0.7,
110 | # max_tokens=1200,
111 | # )
112 | #
113 |
114 | # Create the Company Analyst Tools list
115 | def get_forecaster_tools() -> List[Tool]:
116 | return [
117 | FunctionTool(
118 | analyze_and_predict,
119 | description=(
120 | "Interprets the JSON output from ExtendedCombinedAnalysisAgent. "
121 | "Generates a final Buy/Sell/Hold recommendation with a structured rationale, "
122 | "risk factors, disclaimers, and an explanation of the probability or confidence."
123 | ),
124 | ),
125 | ]
126 |
127 |
128 | @default_subscription
129 | class ForecasterAgent(BaseAgent):
130 | def __init__(
131 | self,
132 | model_client: AzureOpenAIChatCompletionClient,
133 | session_id: str,
134 | user_id: str,
135 | memory: CosmosBufferedChatCompletionContext,
136 | forecaster_tools: List[Tool],
137 | forecaster_tool_agent_id: AgentId,
138 | ):
139 | super().__init__(
140 | "ForecasterAgent",
141 | model_client,
142 | session_id,
143 | user_id,
144 | memory,
145 | forecaster_tools,
146 | forecaster_tool_agent_id,
147 | #system_message="You are an AI Agent. You have knowledge about the SEC annual (10-K) and quarterly (10-Q) reports. SEC reports includes the information about income statement, balance sheet, cash flow, risk assessment, competitor analysis, business highlights and business information."
148 | system_message=dedent(
149 | f"""
150 | You are a Forecaster and Analysis Agent.
151 | Your role is to interpret the output of an extended technical & fundamental analysis pipeline
152 | and additional data from the list of one or more the following:
153 | - Business Overview
154 | - Risk Assessment
155 | - Market Position
156 | - Income Statement
157 | - Segment Statement
158 | - Income Summarization
159 | - Competitor Analysis
160 | - Business Highlights
161 | - Business Information
162 | - Earnings Call Transcripts
163 | - SEC Reports
164 | - Analyst Reports
165 | - News
166 | - Stock Price Data
167 | Produce a final recommendation (Buy, Sell, or Hold) with
168 | a structured format and thorough, bullet-pointed explanation.
169 | You must mention the final probability, interpret it as confidence level,
170 | and provide disclaimers like "Past performance is not indicative of future results.
171 | """
172 | )
173 | )
174 |
--------------------------------------------------------------------------------
/src/backend/helpers/yfutils.py:
--------------------------------------------------------------------------------
1 | import yfinance as yf
2 | from typing import Annotated, Callable, Any, Optional
3 | from pandas import DataFrame
4 | from functools import wraps
5 | from helpers.dutils import decorate_all_methods
6 | from helpers.summarizeutils import get_next_weekday, save_output, SavePathType
7 | import random
8 | from datetime import datetime
9 |
10 | def init_ticker(func: Callable) -> Callable:
11 | """Decorator to initialize yf.Ticker and pass it to the function."""
12 |
13 | @wraps(func)
14 | def wrapper(symbol: Annotated[str, "ticker symbol"], *args, **kwargs) -> Any:
15 | ticker = yf.Ticker(symbol)
16 | return func(ticker, *args, **kwargs)
17 |
18 | return wrapper
19 |
20 |
21 | @decorate_all_methods(init_ticker)
22 | class yfUtils:
23 |
24 | def get_stock_data(
25 | symbol: Annotated[str, "ticker symbol"],
26 | start_date: Annotated[
27 | str, "start date for retrieving stock price data, YYYY-mm-dd"
28 | ],
29 | end_date: Annotated[
30 | str, "end date for retrieving stock price data, YYYY-mm-dd"
31 | ],
32 | save_path: SavePathType = None,
33 | ) -> DataFrame:
34 | """retrieve stock price data for designated ticker symbol"""
35 | ticker = symbol
36 | stock_data = ticker.history(start=start_date, end=end_date)
37 | save_output(stock_data, f"Stock data for {ticker.ticker}", save_path)
38 | return stock_data
39 |
40 | def get_stock_info(
41 | symbol: Annotated[str, "ticker symbol"],
42 | ) -> dict:
43 | """Fetches and returns latest stock information."""
44 | ticker = symbol
45 | stock_info = ticker.info
46 | return stock_info
47 |
48 | def get_company_info(
49 | symbol: Annotated[str, "ticker symbol"],
50 | save_path: Optional[str] = None,
51 | ) -> DataFrame:
52 | """Fetches and returns company information as a DataFrame."""
53 | ticker = symbol
54 | info = ticker.info
55 | company_info = {
56 | "Company Name": info.get("shortName", "N/A"),
57 | "Industry": info.get("industry", "N/A"),
58 | "Sector": info.get("sector", "N/A"),
59 | "Country": info.get("country", "N/A"),
60 | "Website": info.get("website", "N/A"),
61 | }
62 | company_info_df = DataFrame([company_info])
63 | if save_path:
64 | company_info_df.to_csv(save_path)
65 | print(f"Company info for {ticker.ticker} saved to {save_path}")
66 | return company_info_df
67 |
68 | def get_stock_dividends(
69 | symbol: Annotated[str, "ticker symbol"],
70 | save_path: Optional[str] = None,
71 | ) -> DataFrame:
72 | """Fetches and returns the latest dividends data as a DataFrame."""
73 | ticker = symbol
74 | dividends = ticker.dividends
75 | if save_path:
76 | dividends.to_csv(save_path)
77 | print(f"Dividends for {ticker.ticker} saved to {save_path}")
78 | return dividends
79 |
80 | def get_income_stmt(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
81 | """Fetches and returns the latest income statement of the company as a DataFrame."""
82 | ticker = symbol
83 | income_stmt = ticker.financials
84 | return income_stmt
85 |
86 | def get_balance_sheet(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
87 | """Fetches and returns the latest balance sheet of the company as a DataFrame."""
88 | ticker = symbol
89 | balance_sheet = ticker.balance_sheet
90 | return balance_sheet
91 |
92 | def get_cash_flow(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
93 | """Fetches and returns the latest cash flow statement of the company as a DataFrame."""
94 | ticker = symbol
95 | cash_flow = ticker.cashflow
96 | return cash_flow
97 |
98 | def get_company_news(
99 | symbol: Annotated[str, "ticker symbol"],
100 | start_date: Annotated[
101 | str,
102 | "start date of the search period for the company's basic financials, yyyy-mm-dd",
103 | ],
104 | end_date: Annotated[
105 | str,
106 | "end date of the search period for the company's basic financials, yyyy-mm-dd",
107 | ],
108 | max_news_num: Annotated[
109 | int, "maximum number of news to return, default to 10"
110 | ] = 25,
111 | ) -> DataFrame:
112 | """Get the url and filing date of the 10-K report for a given stock and year"""
113 |
114 | ticker = symbol
115 | tickerNews = ticker.news
116 |
117 | if tickerNews:
118 | news = [
119 | {
120 | #"date": datetime.fromtimestamp(n["providerPublishTime"]).strftime("%Y-%m-%d %H%M%S"),
121 | "date": n['content']["pubDate"],
122 | "headline": n['content']["title"],
123 | "summary": n['content']["summary"],
124 | }
125 | for n in tickerNews
126 | ]
127 | if len(news) > max_news_num:
128 | news = random.choices(news, k=max_news_num)
129 | news.sort(key=lambda x: x["date"])
130 | output = DataFrame(news)
131 | return output
132 | else:
133 | return f"Failed to retrieve data: {symbol}"
134 |
135 | def get_analyst_recommendations(symbol: Annotated[str, "ticker symbol"]) -> tuple:
136 | """Fetches the latest analyst recommendations and returns the most common recommendation and its count."""
137 | ticker = symbol
138 | recommendations = ticker.recommendations
139 | if recommendations.empty:
140 | return None, 0 # No recommendations available
141 |
142 | # Assuming 'period' column exists and needs to be excluded
143 | row_0 = recommendations.iloc[0, 1:] # Exclude 'period' column if necessary
144 |
145 | # Find the maximum voting result
146 | max_votes = row_0.max()
147 | majority_voting_result = row_0[row_0 == max_votes].index.tolist()
148 |
149 | return majority_voting_result[0], max_votes
150 |
151 | def get_fundamentals(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
152 | """Fetches and returns the latest fundamentals data as a DataFrame."""
153 | ticker = symbol
154 | info = ticker.info # yfinance's fundamental data
155 | # Some commonly used fields: 'forwardPE', 'trailingPE', 'priceToBook', 'beta', 'profitMargins', etc.
156 | # Not all fields are guaranteed to exist for every ticker.
157 | fundamentals = {
158 | "forwardPE": info.get("forwardPE", None),
159 | "trailingPE": info.get("trailingPE", None),
160 | "priceToBook": info.get("priceToBook", None),
161 | "beta": info.get("beta", None),
162 | "bookValue": info.get("bookValue", None),
163 | "trailingEps": info.get("trailingEps", None),
164 | "forwardEps": info.get("forwardEps", None),
165 | "enterpriseToRevenue": info.get("enterpriseToRevenue", None),
166 | "enterpriseToEbitda": info.get("enterpriseToEbitda", None),
167 | "debtToEquity": info.get("debtToEquity", None),
168 | "returnOnEquity": info.get("returnOnEquity", None),
169 | "returnOnAssets": info.get("returnOnAssets", None),
170 | "currentRatio": info.get("currentRatio", None),
171 | "quickRatio": info.get("quickRatio", None),
172 | "trailingPegRatio": info.get("trailingPegRatio", None),
173 | }
174 |
175 | fundamentals_df = DataFrame([fundamentals])
176 | return fundamentals_df
--------------------------------------------------------------------------------
/src/frontend/wwwroot/assets/app-logo.svg:
--------------------------------------------------------------------------------
1 |
65 |
--------------------------------------------------------------------------------
/src/backend/helpers/secutils.py:
--------------------------------------------------------------------------------
1 | import os
2 | import requests
3 | from sec_api import ExtractorApi, QueryApi, RenderApi
4 | from functools import wraps
5 | from typing import Annotated
6 | from helpers.fmputils import fmpUtils
7 | from helpers.dutils import decorate_all_methods
8 | from helpers.summarizeutils import SavePathType
9 |
10 | CACHE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".cache")
11 | PDF_GENERATOR_API = "https://api.sec-api.io/filing-reader"
12 |
13 |
14 | def init_sec_api(func):
15 | @wraps(func)
16 | def wrapper(*args, **kwargs):
17 | global extractor_api, query_api, render_api
18 | if os.environ.get("SEC_API_KEY") is None:
19 | print("Please set the environment variable SEC_API_KEY to use sec_api.")
20 | return None
21 | else:
22 | extractor_api = ExtractorApi(os.environ["SEC_API_KEY"])
23 | query_api = QueryApi(os.environ["SEC_API_KEY"])
24 | render_api = RenderApi(os.environ["SEC_API_KEY"])
25 | print("Sec Api initialized")
26 | return func(*args, **kwargs)
27 |
28 | return wrapper
29 |
30 |
31 | @decorate_all_methods(init_sec_api)
32 | class SECUtils:
33 |
34 | def get_10k_metadata(
35 | ticker: Annotated[str, "ticker symbol"],
36 | start_date: Annotated[
37 | str, "start date of the 10-k file search range, in yyyy-mm-dd format"
38 | ],
39 | end_date: Annotated[
40 | str, "end date of the 10-k file search range, in yyyy-mm-dd format"
41 | ],
42 | ):
43 | """
44 | Search for 10-k filings within a given time period, and return the meta data of the latest one
45 | """
46 | query = {
47 | "query": f'ticker:"{ticker}" AND formType:"10-K" AND filedAt:[{start_date} TO {end_date}]',
48 | "from": 0,
49 | "size": 10,
50 | "sort": [{"filedAt": {"order": "desc"}}],
51 | }
52 | response = query_api.get_filings(query)
53 | if response["filings"]:
54 | return response["filings"][0]
55 | return None
56 |
57 | def download_10k_filing(
58 | ticker: Annotated[str, "ticker symbol"],
59 | start_date: Annotated[
60 | str, "start date of the 10-k file search range, in yyyy-mm-dd format"
61 | ],
62 | end_date: Annotated[
63 | str, "end date of the 10-k file search range, in yyyy-mm-dd format"
64 | ],
65 | save_folder: Annotated[
66 | str, "name of the folder to store the downloaded filing"
67 | ],
68 | ) -> str:
69 | """Download the latest 10-K filing as htm for a given ticker within a given time period."""
70 | metadata = SECUtils.get_10k_metadata(ticker, start_date, end_date)
71 | if metadata:
72 | ticker = metadata["ticker"]
73 | url = metadata["linkToFilingDetails"]
74 |
75 | try:
76 | date = metadata["filedAt"][:10]
77 | file_name = date + "_" + metadata["formType"] + "_" + url.split("/")[-1]
78 |
79 | if not os.path.isdir(save_folder):
80 | os.makedirs(save_folder)
81 |
82 | file_content = render_api.get_filing(url)
83 | file_path = os.path.join(save_folder, file_name)
84 | with open(file_path, "w") as f:
85 | f.write(file_content)
86 | return f"{ticker}: download succeeded. Saved to {file_path}"
87 | except:
88 | return f"❌ {ticker}: downloaded failed: {url}"
89 | else:
90 | return f"No 2023 10-K filing found for {ticker}"
91 |
92 | def download_10k_pdf(
93 | ticker: Annotated[str, "ticker symbol"],
94 | start_date: Annotated[
95 | str, "start date of the 10-k file search range, in yyyy-mm-dd format"
96 | ],
97 | end_date: Annotated[
98 | str, "end date of the 10-k file search range, in yyyy-mm-dd format"
99 | ],
100 | save_folder: Annotated[
101 | str, "name of the folder to store the downloaded pdf filing"
102 | ],
103 | ) -> str:
104 | """Download the latest 10-K filing as pdf for a given ticker within a given time period."""
105 | metadata = SECUtils.get_10k_metadata(ticker, start_date, end_date)
106 | if metadata:
107 | ticker = metadata["ticker"]
108 | filing_url = metadata["linkToFilingDetails"]
109 |
110 | try:
111 | date = metadata["filedAt"][:10]
112 | print(filing_url.split("/")[-1])
113 | file_name = (
114 | date
115 | + "_"
116 | + metadata["formType"].replace("/A", "")
117 | + "_"
118 | + filing_url.split("/")[-1]
119 | + ".pdf"
120 | )
121 |
122 | if not os.path.isdir(save_folder):
123 | os.makedirs(save_folder)
124 |
125 | api_url = f"{PDF_GENERATOR_API}?token={os.environ['SEC_API_KEY']}&type=pdf&url={filing_url}"
126 | response = requests.get(api_url, stream=True)
127 | response.raise_for_status()
128 |
129 | file_path = os.path.join(save_folder, file_name)
130 | with open(file_path, "wb") as file:
131 | for chunk in response.iter_content(chunk_size=8192):
132 | file.write(chunk)
133 | return f"{ticker}: download succeeded. Saved to {file_path}"
134 | except Exception as e:
135 | return f"❌ {ticker}: downloaded failed: {filing_url}, {e}"
136 | else:
137 | return f"No 2023 10-K filing found for {ticker}"
138 |
139 | def get_10k_section(
140 | ticker_symbol: Annotated[str, "ticker symbol"],
141 | fyear: Annotated[str, "fiscal year of the 10-K report"],
142 | section: Annotated[
143 | str | int,
144 | "Section of the 10-K report to extract, should be in [1, 1A, 1B, 2, 3, 4, 5, 6, 7, 7A, 8, 9, 9A, 9B, 10, 11, 12, 13, 14, 15]",
145 | ],
146 | report_address: Annotated[
147 | str,
148 | "URL of the 10-K report, if not specified, will get report url from fmp api",
149 | ] = None,
150 | save_path: SavePathType = None,
151 | ) -> str:
152 | """
153 | Get a specific section of a 10-K report from the SEC API.
154 | """
155 | if isinstance(section, int):
156 | section = str(section)
157 | if section not in [
158 | "1A",
159 | "1B",
160 | "7A",
161 | "9A",
162 | "9B",
163 | ] + [str(i) for i in range(1, 16)]:
164 | raise ValueError(
165 | "Section must be in [1, 1A, 1B, 2, 3, 4, 5, 6, 7, 7A, 8, 9, 9A, 9B, 10, 11, 12, 13, 14, 15]"
166 | )
167 |
168 | # os.makedirs(f"{self.project_dir}/10k", exist_ok=True)
169 |
170 | # report_name = f"{self.project_dir}/10k/section_{section}.txt"
171 |
172 | # if USE_CACHE and os.path.exists(report_name):
173 | # with open(report_name, "r") as f:
174 | # section_text = f.read()
175 | # else:
176 | if report_address is None:
177 | report_address = fmpUtils.get_sec_report(ticker_symbol, fyear)
178 | if report_address.startswith("Link: "):
179 | report_address = report_address.lstrip("Link: ").split()[0]
180 | else:
181 | return report_address # debug info
182 |
183 | cache_path = os.path.join(
184 | CACHE_PATH, f"sec_utils/{ticker_symbol}_{fyear}_{section}.txt"
185 | )
186 | if os.path.exists(cache_path):
187 | with open(cache_path, "r") as f:
188 | section_text = f.read()
189 | else:
190 | section_text = extractor_api.get_section(report_address, section, "text")
191 | os.makedirs(os.path.dirname(cache_path), exist_ok=True)
192 | with open(cache_path, "w") as f:
193 | f.write(section_text)
194 |
195 | if save_path:
196 | os.makedirs(os.path.dirname(save_path), exist_ok=True)
197 | with open(save_path, "w") as f:
198 | f.write(section_text)
199 |
200 | return section_text
--------------------------------------------------------------------------------